return path.split('/').map((segment) => encodeURIComponent(segment)).join('/'); } <del> export async function getLink(gitAPI: GitAPI, useSelection: boolean, hostPrefix?: string, linkType: 'permalink' | 'headlink' = 'permalink', context?: LinkContext, useRange?: boolean): Promise<string | undefined> { </del> <ins> export async function getLink(gitAPI: GitAPI, useSelection: boolean, shouldEnsurePublished: boolean, hostPrefix?: string, linkType: 'permalink' | 'headlink' = 'permalink', context?: LinkContext, useRange?: boolean): Promise<string | undefined> { </ins> hostPrefix = hostPrefix ?? 'https://github.com'; const fileAndPosition = getFileAndPosition(context); if (!fileAndPosition) {


return; } <del> await ensurePublished(gitRepo, uri); </del> <ins> if (shouldEnsurePublished) { await ensurePublished(gitRepo, uri); } </ins> let repo: { owner: string; repo: string } | undefined; gitRepo.state.remotes.find(remote => {


} } <del> for (let i = (renderActions.length - 1); i !== 0; i--) { </del> <ins> for (let i = (renderActions.length - 1); i > 0; i--) { </ins> const temp = renderActions[i]; if (temp.size === 0) { continue;


const data = this.editorTransfer.getData(DraggedEditorIdentifier.prototype); if (Array.isArray(data)) { const draggedEditor = data[0].identifier; <del> const targetGroup = ensureTargetGroup(); </del> const sourceGroup = this.accessor.getGroup(draggedEditor.groupId); if (sourceGroup) { <del> if (sourceGroup === targetGroup) { return; </del> <ins> const copyEditor = this.isCopyOperation(event, draggedEditor); let targetGroup: IEditorGroupView | undefined = undefined; // Optimization: if we move the last editor of an editor group // and we are configured to close empty editor groups, we can // rather move the entire editor group according to the direction if (this.editorGroupService.partOptions.closeEmptyGroups && sourceGroup.count === 1 && typeof splitDirection === 'number' && !copyEditor) { targetGroup = this.accessor.moveGroup(sourceGroup, this.groupView, splitDirection); </ins> } <del> // Open in target group const options = fillActiveEditorViewState(sourceGroup, draggedEditor.editor, { pinned: true,										// always pin dropped editor sticky: sourceGroup.isSticky(draggedEditor.editor),	// preserve sticky state }); </del> <ins> // In any other case do a normal move/copy operation else { targetGroup = ensureTargetGroup(); if (sourceGroup === targetGroup) { return; } </ins> <del> const copyEditor = this.isCopyOperation(event, draggedEditor); if (!copyEditor) { sourceGroup.moveEditor(draggedEditor.editor, targetGroup, options); } else { sourceGroup.copyEditor(draggedEditor.editor, targetGroup, options); </del> <ins> // Open in target group const options = fillActiveEditorViewState(sourceGroup, draggedEditor.editor, { pinned: true,										// always pin dropped editor sticky: sourceGroup.isSticky(draggedEditor.editor),	// preserve sticky state }); if (!copyEditor) { sourceGroup.moveEditor(draggedEditor.editor, targetGroup, options); } else { sourceGroup.copyEditor(draggedEditor.editor, targetGroup, options); } </ins> } // Ensure target has focus


"jschardet": "3.0.0", "keytar": "7.9.0", "minimist": "^1.2.6", <del> "native-is-elevated": "0.6.0", </del> <ins> "native-is-elevated": "0.7.0", </ins> "native-keymap": "^3.3.2", "native-watchdog": "^1.4.1", "node-pty": "1.1.0-beta1",


resolved "https://registry.yarnpkg.com/napi-build-utils/-/napi-build-utils-1.0.2.tgz#b1fddc0b2c46e380a0b7a76f984dd47c41a13806" integrity sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg== <del> native-is-elevated@0.6.0: version "0.6.0" resolved "https://registry.yarnpkg.com/native-is-elevated/-/native-is-elevated-0.6.0.tgz#9fd9c9c53bfd87d6e6af15a5d6bcb8e592b7ec79" integrity sha512-HW1wDo4WYZC7W68kaS0cs7FtDTrcFoAY1APc4SlU4Un/FuL7pjilXFEteBCA58EWClKk0912JLIoekOJ/NohnQ== </del> <ins> native-is-elevated@0.7.0: version "0.7.0" resolved "https://registry.yarnpkg.com/native-is-elevated/-/native-is-elevated-0.7.0.tgz#77499639e232edad1886403969e2bf236294e7af" integrity sha512-tp8hUqK7vexBiyIWKMvmRxdG6kqUtO+3eay9iB0i16NYgvCqE5wMe1Y0guHilpkmRgvVXEWNW4et1+qqcwpLBA== </ins> native-keymap@^3.3.2: version "3.3.3"


import * as dom from 'vs/base/browser/dom'; import { StandardMouseEvent } from 'vs/base/browser/mouseEvent'; import { createTrustedTypesPolicy } from 'vs/base/browser/trustedTypes'; <del> import { equals } from 'vs/base/common/arrays'; </del> import { Disposable, DisposableStore } from 'vs/base/common/lifecycle'; import 'vs/css!./stickyScroll'; import { ICodeEditor, IOverlayWidget, IOverlayWidgetPosition } from 'vs/editor/browser/editorBrowser';


readonly lineNumbers: number[], readonly lastLineRelativePosition: number ) { } <del> public equals(other: StickyScrollWidgetState | undefined): boolean { return !!other && this.lastLineRelativePosition === other.lastLineRelativePosition && equals(this.lineNumbers, other.lineNumbers); } </del> } const _ttPolicy = createTrustedTypesPolicy('stickyScrollViewLayer', { createHTML: value => value });


private _lastLineRelativePosition: number = 0; private _hoverOnLine: number = -1; private _hoverOnColumn: number = -1; <del> private _state: StickyScrollWidgetState | undefined; </del> constructor( private readonly _editor: ICodeEditor


} setState(state: StickyScrollWidgetState): void { <del> if (state.equals(this._state)) { return; } this._state = state; </del> dom.clearNode(this._rootDomNode); this._disposableStore.clear(); this._lineNumbers.length = 0;


private _onDidChangeTaskSystemInfo: Emitter<void> = new Emitter(); private _willRestart: boolean = false; public onDidChangeTaskSystemInfo: Event<void> = this._onDidChangeTaskSystemInfo.event; <ins> private _onDidReconnectToTasks: Emitter<void> = new Emitter(); public onDidReconnectToTasks: Event<void> = this._onDidReconnectToTasks.event; </ins> constructor( @IConfigurationService private readonly _configurationService: IConfigurationService,


} this.getWorkspaceTasks(TaskRunSource.Reconnect).then(async () => { this._tasksReconnected = await this._reconnectTasks(); <ins> this._onDidReconnectToTasks.fire(); </ins> }); }


} if (executeResult.kind === TaskExecuteKind.Active) { const active = executeResult.active; <ins> if (active && active.same && runSource === TaskRunSource.FolderOpen) { // ignore, the task is already active, likely from being reconnected. this._logService.debug('Ignoring task that is already active', executeResult.task); return executeResult.promise; } </ins> if (active && active.same) { if (this._taskSystem?.isTaskVisible(executeResult.task)) { const message = nls.localize('TaskSystem.activeSame.noBackground', 'The task '{0}' is already active.', executeResult.task.getQualifiedLabel());


@IWorkspaceTrustManagementService private readonly _workspaceTrustManagementService: IWorkspaceTrustManagementService, @ILogService private readonly _logService: ILogService) { super(); <del> if (this._workspaceTrustManagementService.isWorkspaceTrusted()) { this._tryRunTasks(); } </del> <ins> this._taskService.onDidReconnectToTasks((() => { if (this._workspaceTrustManagementService.isWorkspaceTrusted()) { this._tryRunTasks(); } })); </ins> this._register(this._workspaceTrustManagementService.onDidChangeTrust(async trusted => { if (trusted) { await this._tryRunTasks();


export interface ITaskService { readonly _serviceBrand: undefined; onDidStateChange: Event<ITaskEvent>; <ins> onDidReconnectToTasks: Event<void>; </ins> supportsMultipleTaskExecutions: boolean; configureAction(): Action;


} }; observable.addObserver(observer); <ins> observable.reportChanges(); </ins> return { dispose() { observable.removeObserver(observer);


*--------------------------------------------------------------------------------------------*/ import * as assert from 'assert'; <del> import { Emitter } from 'vs/base/common/event'; </del> <ins> import { Emitter, Event } from 'vs/base/common/event'; </ins> import { ISettableObservable, autorun, derived, ITransaction, observableFromEvent, observableValue, transaction, keepAlive } from 'vs/base/common/observable'; import { BaseObservable, IObservable, IObserver } from 'vs/base/common/observableImpl/base';


myObservable2.set(1, tx); }); }); <ins> test('bug: fromObservableLight doesnt subscribe', () => { const log = new Log(); const myObservable = new LoggingObservableValue('myObservable', 0, log); const myDerived = derived('myDerived', reader => { const val = myObservable.read(reader); log.log(`myDerived.computed(myObservable2: ${val})`); return val % 10; }); const e = Event.fromObservableLight(myDerived); log.log('event created'); e(() => { log.log('event fired'); }); myObservable.set(1, undefined); assert.deepStrictEqual(log.getAndClearEntries(), [ 'event created', 'myObservable.firstObserverAdded', 'myObservable.get', 'myDerived.computed(myObservable2: 0)', 'myObservable.set (value 1)', 'myObservable.get', 'myDerived.computed(myObservable2: 1)', 'event fired', ]); }); </ins> }); export class LoggingObserver implements IObserver {


private _isInLayout: boolean = false; <del> private readonly _viewContext: ViewContext; </del> private _webviewElement: FastDomNode<HTMLElement> | null = null; get webviewElement() {


) { super(listUser, container, delegate, renderers, options, contextKeyService, listService, configurationService, instantiationService); NOTEBOOK_CELL_LIST_FOCUSED.bindTo(this.contextKeyService).set(true); <del> this._viewContext = viewContext; </del> this._previousFocusedElements = this.getFocusedElements(); this._localDisposableStore.add(this.onDidChangeFocus((e) => { this._previousFocusedElements.forEach(element => {


const scrollHeight = this.view.scrollHeight; const scrollTop = this.getViewScrollTop(); const wrapperBottom = this.getViewScrollBottom(); <del> const topInsertToolbarHeight = this._viewContext.notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType); this.view.setScrollTop(scrollHeight - (wrapperBottom - scrollTop) - topInsertToolbarHeight); </del> <ins> this.view.setScrollTop(scrollHeight - (wrapperBottom - scrollTop)); </ins> } //#region Reveal Cell synchronously


} getViewScrollBottom() { <del> const topInsertToolbarHeight = this._viewContext.notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType); return this.getViewScrollTop() + this.view.renderHeight - topInsertToolbarHeight; </del> <ins> return this.getViewScrollTop() + this.view.renderHeight; </ins> } setCellEditorSelection(cell: ICellViewModel, range: Range) {


import * as assert from 'assert'; import { DisposableStore } from 'vs/base/common/lifecycle'; <del> import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; </del> import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock'; import { CellKind } from 'vs/workbench/contrib/notebook/common/notebookCommon'; <del> import { INotebookExecutionStateService } from 'vs/workbench/contrib/notebook/common/notebookExecutionStateService'; import { NotebookOptions } from 'vs/workbench/contrib/notebook/browser/notebookOptions'; </del> import { createNotebookCellList, setupInstantiationService, withTestNotebook } from 'vs/workbench/contrib/notebook/test/browser/testNotebookEditor'; suite('NotebookCellList', () => { let disposables: DisposableStore; let instantiationService: TestInstantiationService; <del> let notebookDefaultOptions: NotebookOptions; let topInsertToolbarHeight: number; </del> suiteSetup(() => { disposables = new DisposableStore(); instantiationService = setupInstantiationService(disposables); <del> notebookDefaultOptions = new NotebookOptions(instantiationService.get(IConfigurationService), instantiationService.get(INotebookExecutionStateService), false); topInsertToolbarHeight = notebookDefaultOptions.computeTopInsertToolbarHeight(); </del> }); suiteTeardown(() => disposables.dispose());


cellList.attachViewModel(viewModel); // render height 210, it can render 3 full cells and 1 partial cell <del> cellList.layout(210 + topInsertToolbarHeight, 100); </del> <ins> cellList.layout(210, 100); </ins> // scroll a bit, scrollTop to bottom: 5, 215 cellList.scrollTop = 5;


cellList.attachViewModel(viewModel); // render height 210, it can render 3 full cells and 1 partial cell <del> cellList.layout(210 + topInsertToolbarHeight, 100); </del> <ins> cellList.layout(210, 100); </ins> // init scrollTop and scrollBottom assert.deepStrictEqual(cellList.scrollTop, 0);


if (this._isVisible) { const notificationsList = assertIsDefined(this.notificationsList); <del> // Make visible and focus first notificationsList.show(true /* focus */); </del> <ins> // Make visible notificationsList.show(); // Focus first </ins> notificationsList.focusFirst(); return; // already visible


import { NotificationsListDelegate, NotificationRenderer } from 'vs/workbench/browser/parts/notifications/notificationsViewer'; import { CopyNotificationMessageAction } from 'vs/workbench/browser/parts/notifications/notificationsActions'; import { IContextMenuService } from 'vs/platform/contextview/browser/contextView'; <del> import { assertIsDefined, assertAllDefined } from 'vs/base/common/types'; </del> <ins> import { assertAllDefined } from 'vs/base/common/types'; </ins> import { NotificationFocusedContext } from 'vs/workbench/common/contextkeys'; import { Disposable } from 'vs/base/common/lifecycle'; import { AriaRole } from 'vs/base/browser/ui/aria/aria';


super(); } <del> show(focus?: boolean): void { </del> <ins> show(): void { </ins> if (this.isVisible) { <del> if (focus) { const list = assertIsDefined(this.list); list.domFocus(); } </del> return; // already visible }


// Make visible this.isVisible = true; <del> // Focus if (focus) { const list = assertIsDefined(this.list); list.domFocus(); } </del> } private createNotificationsList(): void {


} focusFirst(): void { <del> if (!this.isVisible || !this.list) { return; // hidden </del> <ins> if (!this.list) { return; // not created yet </ins> } this.list.focusFirst();


} hasFocus(): boolean { <del> if (!this.isVisible || !this.listContainer) { return false; // hidden </del> <ins> if (!this.listContainer) { return false; // not created yet </ins> } return isAncestor(document.activeElement, this.listContainer);


} } <ins> const textTokenTypes = new Set(['paragraph_open', 'inline', 'heading_open', 'ordered_list_open', 'bullet_list_open', 'list_item_open', 'blockquote_open']); </ins> async function shouldSmartPasteForSelection( parser: IMdParser, document: ITextDocument,


if (token.isCancellationRequested) { return false; } <del> for (const token of tokens) { if (token.map && token.map[0] <= selectedRange.start.line && token.map[1] > selectedRange.start.line) { if (!['paragraph_open', 'inline', 'heading_open', 'ordered_list_open', 'bullet_list_open', 'list_item_open', 'blockquote_open'].includes(token.type)) { </del> <ins> for (let i = 0; i < tokens.length; i++) { const token = tokens[i]; if (!token.map) { continue; } if (token.map[0] <= selectedRange.start.line && token.map[1] > selectedRange.start.line) { if (!textTokenTypes.has(token.type)) { return false; } } // Special case for html such as: // // <b> // | // </b> // // In this case pasting will cause the html block to be created even though the cursor is not currently inside a block if (token.type === 'html_block' && token.map[1] === selectedRange.start.line) { const nextToken = tokens.at(i + 1); // The next token does not need to be a html_block, but it must be on the next line if (nextToken?.map?.[0] === selectedRange.end.line + 1) { </ins> return false; } }


 /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ import * as assert from 'assert'; import 'mocha'; import * as vscode from 'vscode'; import { InMemoryDocument } from '../client/inMemoryDocument'; import { PasteUrlAsMarkdownLink, findValidUriInText, shouldInsertMarkdownLinkByDefault } from '../languageFeatures/copyFiles/pasteUrlProvider'; import { createInsertUriListEdit } from '../languageFeatures/copyFiles/shared'; import { createNewMarkdownEngine } from './engine'; import { noopToken } from '../util/cancellation'; function makeTestDoc(contents: string) { return new InMemoryDocument(vscode.Uri.file('test.md'), contents); } suite('createEditAddingLinksForUriList', () => { test('Markdown Link Pasting should occur for a valid link (end to end)', async () => { // createEditAddingLinksForUriList -> checkSmartPaste -> tryGetUriListSnippet -> createUriListSnippet -> createLinkSnippet const result = createInsertUriListEdit( new InMemoryDocument(vscode.Uri.file('test.md'), 'hello world!'), [new vscode.Range(0, 0, 0, 12)], 'https://www.microsoft.com/'); // need to check the actual result -> snippet value assert.strictEqual(result?.label, 'Insert Markdown Link'); }); suite('validateLink', () => { test('Markdown pasting should occur for a valid link', () => { assert.strictEqual( findValidUriInText('https://www.microsoft.com/'), 'https://www.microsoft.com/'); }); test('Markdown pasting should occur for a valid link preceded by a new line', () => { assert.strictEqual( findValidUriInText('rnhttps://www.microsoft.com/'), 'https://www.microsoft.com/'); }); test('Markdown pasting should occur for a valid link followed by a new line', () => { assert.strictEqual( findValidUriInText('https://www.microsoft.com/rn'), 'https://www.microsoft.com/'); }); test('Markdown pasting should not occur for a valid hostname and invalid protool', () => { assert.strictEqual( findValidUriInText('invalid:www.microsoft.com'), undefined); }); test('Markdown pasting should not occur for plain text', () => { assert.strictEqual( findValidUriInText('hello world!'), undefined); }); test('Markdown pasting should not occur for plain text including a colon', () => { assert.strictEqual( findValidUriInText('hello: world!'), undefined); }); test('Markdown pasting should not occur for plain text including a slashes', () => { assert.strictEqual( findValidUriInText('helloworld!'), undefined); }); test('Markdown pasting should not occur for a link followed by text', () => { assert.strictEqual( findValidUriInText('https://www.microsoft.com/ hello world!'), undefined); }); test('Markdown pasting should occur for a link preceded or followed by spaces', () => { assert.strictEqual( findValidUriInText('     https://www.microsoft.com/     '), 'https://www.microsoft.com/'); }); test('Markdown pasting should not occur for a link with an invalid scheme', () => { assert.strictEqual( findValidUriInText('hello:www.microsoft.com'), undefined); }); test('Markdown pasting should not occur for multiple links being pasted', () => { assert.strictEqual( findValidUriInText('https://www.microsoft.com/rnhttps://www.microsoft.com/rnhttps://www.microsoft.com/rnhttps://www.microsoft.com/'), undefined); }); test('Markdown pasting should not occur for multiple links with spaces being pasted', () => { assert.strictEqual( findValidUriInText('https://www.microsoft.com/    rnhttps://www.microsoft.com/rnhttps://www.microsoft.com/rn hello rnhttps://www.microsoft.com/'), undefined); }); test('Markdown pasting should not occur for just a valid uri scheme', () => { assert.strictEqual( findValidUriInText('https://'), undefined); }); }); suite('createInsertUriListEdit', () => { test('Should create snippet with < > when pasted link has an mismatched parentheses', () => { const edit = createInsertUriListEdit(makeTestDoc(''), [new vscode.Range(0, 0, 0, 0)], 'https://www.mic(rosoft.com'); assert.strictEqual(edit?.edits?.[0].snippet.value, '[${1:text}](<https://www.mic(rosoft.com>)'); }); test('Should create Markdown link snippet when pasteAsMarkdownLink is true', () => { const edit = createInsertUriListEdit(makeTestDoc(''), [new vscode.Range(0, 0, 0, 0)], 'https://www.microsoft.com'); assert.strictEqual(edit?.edits?.[0].snippet.value, '[${1:text}](https://www.microsoft.com)'); }); test('Should use an unencoded URI string in Markdown link when passing in an external browser link', () => { const edit = createInsertUriListEdit(makeTestDoc(''), [new vscode.Range(0, 0, 0, 0)], 'https://www.microsoft.com'); assert.strictEqual(edit?.edits?.[0].snippet.value, '[${1:text}](https://www.microsoft.com)'); }); test('Should not decode an encoded URI string when passing in an external browser link', () => { const edit = createInsertUriListEdit(makeTestDoc(''), [new vscode.Range(0, 0, 0, 0)], 'https://www.microsoft.com/%20'); assert.strictEqual(edit?.edits?.[0].snippet.value, '[${1:text}](https://www.microsoft.com/%20)'); }); test('Should not encode an unencoded URI string when passing in an external browser link', () => { const edit = createInsertUriListEdit(makeTestDoc(''), [new vscode.Range(0, 0, 0, 0)], 'https://www.example.com/path?query=value&another=value#fragment'); assert.strictEqual(edit?.edits?.[0].snippet.value, '[${1:text}](https://www.example.com/path?query=value&another=value#fragment)'); }); }); suite('shouldInsertMarkdownLinkByDefault', () => { test('Smart should be enabled for selected plain text', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('hello world'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 0, 0, 12)], noopToken), true); }); test('Smart should be enabled in headers', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('# title'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 2, 0, 2)], noopToken), true); }); test('Smart should be enabled in lists', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('1. text'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 3, 0, 3)], noopToken), true); }); test('Smart should be enabled in blockquotes', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('> text'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 3, 0, 3)], noopToken), true); }); test('Smart should be disabled in indented code blocks', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('    code'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 4, 0, 4)], noopToken), false); }); test('Smart should be disabled in fenced code blocks', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('```rnrn```'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 5, 0, 5)], noopToken), false); assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('~~~rnrn~~~'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 5, 0, 5)], noopToken), false); }); test('Smart should be disabled in math blocks', async () => { const katex = (await import('@vscode/markdown-it-katex')).default; const engine = createNewMarkdownEngine(); (await engine.getEngine(undefined)).use(katex); assert.strictEqual( await shouldInsertMarkdownLinkByDefault(engine, makeTestDoc('$$rnrn$$'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 5, 0, 5)], noopToken), false); }); test('Smart should be disabled in link definitions', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('[ref]: http://example.com'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 4, 0, 6)], noopToken), false); assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('[ref]: '), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 7, 0, 7)], noopToken), false); }); test('Smart should be disabled in html blocks', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('
nan
'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(1, 0, 1, 0)], noopToken), false); }); test('Smart should be disabled in Markdown links', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('[a](bcdef)'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 4, 0, 6)], noopToken), false); }); test('Smart should be disabled in Markdown images', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('![a](bcdef)'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 5, 0, 10)], noopToken), false); }); test('Smart should be disabled in inline code', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('``'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 1, 0, 1)], noopToken), false); assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('``'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 0, 0, 0)], noopToken), false); }); test('Smart should be disabled in inline math', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('$$'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 1, 0, 1)], noopToken), false); }); test('Smart should be enabled for empty selection', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('xyz'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 0, 0, 0)], noopToken), true); }); test('SmartWithSelection should disable for empty selection', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('xyz'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 0, 0, 0)], noopToken), false); }); test('Smart should disable for selected link', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('https://www.microsoft.com'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 0, 0, 25)], noopToken), false); }); test('Smart should disable for selected link with trailing whitespace', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('   https://www.microsoft.com  '), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 0, 0, 30)], noopToken), false); }); test('Should evaluate pasteAsMarkdownLink as true for a link pasted in square brackets', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('[abc]'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 1, 0, 4)], noopToken), true); }); test('Should evaluate pasteAsMarkdownLink as false for selected whitespace and new lines', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('   rnrn'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 0, 0, 7)], noopToken), false); }); }); });


 /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ import * as assert from 'assert'; import 'mocha'; import * as vscode from 'vscode'; import { InMemoryDocument } from '../client/inMemoryDocument'; import { PasteUrlAsMarkdownLink, findValidUriInText, shouldInsertMarkdownLinkByDefault } from '../languageFeatures/copyFiles/pasteUrlProvider'; import { createInsertUriListEdit } from '../languageFeatures/copyFiles/shared'; import { createNewMarkdownEngine } from './engine'; import { noopToken } from '../util/cancellation'; function makeTestDoc(contents: string) { return new InMemoryDocument(vscode.Uri.file('test.md'), contents); } suite('createEditAddingLinksForUriList', () => { test('Markdown Link Pasting should occur for a valid link (end to end)', async () => { // createEditAddingLinksForUriList -> checkSmartPaste -> tryGetUriListSnippet -> createUriListSnippet -> createLinkSnippet const result = createInsertUriListEdit( new InMemoryDocument(vscode.Uri.file('test.md'), 'hello world!'), [new vscode.Range(0, 0, 0, 12)], 'https://www.microsoft.com/'); // need to check the actual result -> snippet value assert.strictEqual(result?.label, 'Insert Markdown Link'); }); suite('validateLink', () => { test('Markdown pasting should occur for a valid link', () => { assert.strictEqual( findValidUriInText('https://www.microsoft.com/'), 'https://www.microsoft.com/'); }); test('Markdown pasting should occur for a valid link preceded by a new line', () => { assert.strictEqual( findValidUriInText('rnhttps://www.microsoft.com/'), 'https://www.microsoft.com/'); }); test('Markdown pasting should occur for a valid link followed by a new line', () => { assert.strictEqual( findValidUriInText('https://www.microsoft.com/rn'), 'https://www.microsoft.com/'); }); test('Markdown pasting should not occur for a valid hostname and invalid protool', () => { assert.strictEqual( findValidUriInText('invalid:www.microsoft.com'), undefined); }); test('Markdown pasting should not occur for plain text', () => { assert.strictEqual( findValidUriInText('hello world!'), undefined); }); test('Markdown pasting should not occur for plain text including a colon', () => { assert.strictEqual( findValidUriInText('hello: world!'), undefined); }); test('Markdown pasting should not occur for plain text including a slashes', () => { assert.strictEqual( findValidUriInText('helloworld!'), undefined); }); test('Markdown pasting should not occur for a link followed by text', () => { assert.strictEqual( findValidUriInText('https://www.microsoft.com/ hello world!'), undefined); }); test('Markdown pasting should occur for a link preceded or followed by spaces', () => { assert.strictEqual( findValidUriInText('     https://www.microsoft.com/     '), 'https://www.microsoft.com/'); }); test('Markdown pasting should not occur for a link with an invalid scheme', () => { assert.strictEqual( findValidUriInText('hello:www.microsoft.com'), undefined); }); test('Markdown pasting should not occur for multiple links being pasted', () => { assert.strictEqual( findValidUriInText('https://www.microsoft.com/rnhttps://www.microsoft.com/rnhttps://www.microsoft.com/rnhttps://www.microsoft.com/'), undefined); }); test('Markdown pasting should not occur for multiple links with spaces being pasted', () => { assert.strictEqual( findValidUriInText('https://www.microsoft.com/    rnhttps://www.microsoft.com/rnhttps://www.microsoft.com/rn hello rnhttps://www.microsoft.com/'), undefined); }); test('Markdown pasting should not occur for just a valid uri scheme', () => { assert.strictEqual( findValidUriInText('https://'), undefined); }); }); suite('createInsertUriListEdit', () => { test('Should create snippet with < > when pasted link has an mismatched parentheses', () => { const edit = createInsertUriListEdit(makeTestDoc(''), [new vscode.Range(0, 0, 0, 0)], 'https://www.mic(rosoft.com'); assert.strictEqual(edit?.edits?.[0].snippet.value, '[${1:text}](<https://www.mic(rosoft.com>)'); }); test('Should create Markdown link snippet when pasteAsMarkdownLink is true', () => { const edit = createInsertUriListEdit(makeTestDoc(''), [new vscode.Range(0, 0, 0, 0)], 'https://www.microsoft.com'); assert.strictEqual(edit?.edits?.[0].snippet.value, '[${1:text}](https://www.microsoft.com)'); }); test('Should use an unencoded URI string in Markdown link when passing in an external browser link', () => { const edit = createInsertUriListEdit(makeTestDoc(''), [new vscode.Range(0, 0, 0, 0)], 'https://www.microsoft.com'); assert.strictEqual(edit?.edits?.[0].snippet.value, '[${1:text}](https://www.microsoft.com)'); }); test('Should not decode an encoded URI string when passing in an external browser link', () => { const edit = createInsertUriListEdit(makeTestDoc(''), [new vscode.Range(0, 0, 0, 0)], 'https://www.microsoft.com/%20'); assert.strictEqual(edit?.edits?.[0].snippet.value, '[${1:text}](https://www.microsoft.com/%20)'); }); test('Should not encode an unencoded URI string when passing in an external browser link', () => { const edit = createInsertUriListEdit(makeTestDoc(''), [new vscode.Range(0, 0, 0, 0)], 'https://www.example.com/path?query=value&another=value#fragment'); assert.strictEqual(edit?.edits?.[0].snippet.value, '[${1:text}](https://www.example.com/path?query=value&another=value#fragment)'); }); }); suite('shouldInsertMarkdownLinkByDefault', () => { test('Smart should be enabled for selected plain text', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('hello world'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 0, 0, 12)], noopToken), true); }); test('Smart should be enabled in headers', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('# title'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 2, 0, 2)], noopToken), true); }); test('Smart should be enabled in lists', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('1. text'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 3, 0, 3)], noopToken), true); }); test('Smart should be enabled in blockquotes', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('> text'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 3, 0, 3)], noopToken), true); }); test('Smart should be disabled in indented code blocks', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('    code'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 4, 0, 4)], noopToken), false); }); test('Smart should be disabled in fenced code blocks', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('```rnrn```'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 5, 0, 5)], noopToken), false); assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('~~~rnrn~~~'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 5, 0, 5)], noopToken), false); }); test('Smart should be disabled in math blocks', async () => { const katex = (await import('@vscode/markdown-it-katex')).default; const engine = createNewMarkdownEngine(); (await engine.getEngine(undefined)).use(katex); assert.strictEqual( await shouldInsertMarkdownLinkByDefault(engine, makeTestDoc('$$rnrn$$'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 5, 0, 5)], noopToken), false); }); test('Smart should be disabled in link definitions', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('[ref]: http://example.com'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 4, 0, 6)], noopToken), false); assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('[ref]: '), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 7, 0, 7)], noopToken), false); }); test('Smart should be disabled in html blocks', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('
nan
'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(1, 0, 1, 0)], noopToken), false); }); test('Smart should be disabled in html blocks where paste creates the block', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('
nn
'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(1, 0, 1, 0)], noopToken), false, 'Between two html tags should be treated as html block'); assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('
nntext'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(1, 0, 1, 0)], noopToken), false, 'Between opening html tag and text should be treated as html block'); assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('
nnn
'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(1, 0, 1, 0)], noopToken), true, 'Extra new line after paste should not be treated as html block'); }); test('Smart should be disabled in Markdown links', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('[a](bcdef)'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 4, 0, 6)], noopToken), false); }); test('Smart should be disabled in Markdown images', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('![a](bcdef)'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 5, 0, 10)], noopToken), false); }); test('Smart should be disabled in inline code', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('``'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 1, 0, 1)], noopToken), false); assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('``'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 0, 0, 0)], noopToken), false); }); test('Smart should be disabled in inline math', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('$$'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 1, 0, 1)], noopToken), false); }); test('Smart should be enabled for empty selection', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('xyz'), PasteUrlAsMarkdownLink.Smart, [new vscode.Range(0, 0, 0, 0)], noopToken), true); }); test('SmartWithSelection should disable for empty selection', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('xyz'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 0, 0, 0)], noopToken), false); }); test('Smart should disable for selected link', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('https://www.microsoft.com'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 0, 0, 25)], noopToken), false); }); test('Smart should disable for selected link with trailing whitespace', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('   https://www.microsoft.com  '), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 0, 0, 30)], noopToken), false); }); test('Should evaluate pasteAsMarkdownLink as true for a link pasted in square brackets', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('[abc]'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 1, 0, 4)], noopToken), true); }); test('Should evaluate pasteAsMarkdownLink as false for selected whitespace and new lines', async () => { assert.strictEqual( await shouldInsertMarkdownLinkByDefault(createNewMarkdownEngine(), makeTestDoc('   rnrn'), PasteUrlAsMarkdownLink.SmartWithSelection, [new vscode.Range(0, 0, 0, 7)], noopToken), false); }); }); });


import { resolveMarketplaceHeaders } from 'vs/platform/externalServices/common/marketplace'; import { IStorageService } from 'vs/platform/storage/common/storage'; import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; <ins> import { StopWatch } from 'vs/base/common/stopwatch'; </ins> const CURRENT_TARGET_PLATFORM = isWeb ? TargetPlatform.WEB : getTargetPlatform(platform, arch); const ACTIVITY_HEADER_NAME = 'X-Market-Search-Activity-Id';


} if (needAllVersions.size) { <del> const startTime = new Date().getTime(); </del> <ins> const stopWatch = new StopWatch(); </ins> const query = new Query() .withFlags(flags & ~Flags.IncludeLatestVersionOnly, Flags.IncludeVersions) .withPage(1, needAllVersions.size) .withFilter(FilterType.ExtensionId, ...needAllVersions.keys()); const { extensions } = await this.queryGalleryExtensions(query, criteria, token); this.telemetryService.publicLog2<GalleryServiceAdditionalQueryEvent, GalleryServiceAdditionalQueryClassification>('galleryService:additionalQuery', { <del> duration: new Date().getTime() - startTime, </del> <ins> duration: stopWatch.elapsed(), </ins> count: needAllVersions.size }); for (const extension of extensions) {


'Content-Length': String(data.length), }; <del> const startTime = new Date().getTime(); </del> <ins> const stopWatch = new StopWatch(); </ins> let context: IRequestContext | undefined, error: any, total: number = 0; try {


this.telemetryService.publicLog2<GalleryServiceQueryEvent, GalleryServiceQueryClassification>('galleryService:query', { ...query.telemetryData, requestBodySize: String(data.length), <del> duration: new Date().getTime() - startTime, </del> <ins> duration: stopWatch.elapsed(), </ins> success: !!context && isSuccess(context), responseBodySize: context?.res.headers['Content-Length'], statusCode: context ? String(context.res.statusCode) : undefined,


} } <del> this._currentContent = message + provider.provideContent() + readMoreLink + disableHelpHint + localize('exit-tip', 'nnExit this dialog via the Escape key.'); </del> <ins> this._currentContent = message + provider.provideContent() + readMoreLink + disableHelpHint + localize('exit-tip', 'nExit this dialog via the Escape key.'); </ins> this._updateContextKeys(provider, true); this._getTextModel(URI.from({ path: `accessible-view-${provider.verbositySettingKey}`, scheme: 'accessible-view', fragment: this._currentContent })).then((model) => {


_xterm: Pick<IXtermTerminal, 'getFont' | 'shellIntegration'> & { raw: Terminal }, @IInstantiationService _instantiationService: IInstantiationService, @IKeybindingService private readonly _keybindingService: IKeybindingService, <del> @IAccessibilityService private readonly _accessibilityService: IAccessibilityService, </del> @IContextKeyService private readonly _contextKeyService: IContextKeyService, <del> @ICommandService private readonly _commandService: ICommandService </del> <ins> @ICommandService private readonly _commandService: ICommandService, @IAccessibilityService private readonly _accessibilityService: IAccessibilityService </ins> ) { super(); this._hasShellIntegration = _xterm.shellIntegration.status === ShellIntegrationStatus.VSCode; } private _descriptionForCommand(commandId: string, msg: string, noKbMsg: string): string { <del> const kb = this._keybindingService.lookupKeybindings(commandId); switch (kb.length) { case 0: return format(noKbMsg, commandId); case 1: return format(msg, kb[0].getAriaLabel()); </del> <ins> if (commandId === TerminalCommandId.RunRecentCommand) { const kb = this._keybindingService.lookupKeybindings(commandId); // Run recent command has multiple keybindings. lookupKeybinding just returns the first one regardless of the when context. // Thus, we have to check if accessibility mode is enabled to determine which keybinding to use. return this._accessibilityService.isScreenReaderOptimized() ? format(msg, kb[1].getAriaLabel()) : format(msg, kb[0].getAriaLabel()); </ins> } <del> // Run recent command has multiple keybindings. lookupKeybinding just returns the first one regardless of the when context. // Thus, we have to check if accessibility mode is enabled to determine which keybinding to use. return this._accessibilityService.isScreenReaderOptimized() ? format(msg, kb[1].getAriaLabel()) : format(msg, kb[0].getAriaLabel()); </del> <ins> const kb = this._keybindingService.lookupKeybinding(commandId, this._contextKeyService)?.getAriaLabel(); return !kb ? format(noKbMsg, commandId) : format(msg, kb); </ins> } provideContent(): string {


import { getNotificationFromContext } from 'vs/workbench/browser/parts/notifications/notificationsCommands'; import { IListService, WorkbenchList } from 'vs/platform/list/browser/listService'; import { NotificationFocusedContext } from 'vs/workbench/common/contextkeys'; <del> import { IAccessibleViewService, AccessibleViewService, IAccessibleContentProvider, IAccessibleViewOptions, AccessibleViewType, accessibleViewIsShown } from 'vs/workbench/contrib/accessibility/browser/accessibleView'; </del> <ins> import { IAccessibleViewService, AccessibleViewService, IAccessibleContentProvider, IAccessibleViewOptions, AccessibleViewType } from 'vs/workbench/contrib/accessibility/browser/accessibleView'; </ins> import { IHoverService } from 'vs/workbench/services/hover/browser/hover'; import { alert } from 'vs/base/browser/ui/aria/aria';


const accessibleViewService = accessor.get(IAccessibleViewService); accessibleViewService.next(); return true; <del> }, accessibleViewIsShown)); </del> <ins> })); </ins> this._register(AccessibleViewPreviousAction.addImplementation(95, 'previous', accessor => { const accessibleViewService = accessor.get(IAccessibleViewService); accessibleViewService.previous(); return true; <del> }, accessibleViewIsShown)); </del> <ins> })); </ins> } }


import { KeyCode, KeyMod } from 'vs/base/common/keyCodes'; import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry'; import { MenuId } from 'vs/platform/actions/common/actions'; <ins> import { RawContextKey } from 'vs/platform/contextkey/common/contextkey'; export const accessibilityHelpIsShown = new RawContextKey<boolean>('accessibilityHelpIsShown', false, true); export const accessibleViewIsShown = new RawContextKey<boolean>('accessibleViewIsShown', false, true); </ins> export const enum AccessibilityVerbositySettingId { Terminal = 'accessibility.verbosity.terminal',


export const AccessibleViewNextAction = registerCommand(new MultiCommand({ id: 'editor.action.accessibleViewNext', <del> precondition: undefined, </del> <ins> precondition: accessibleViewIsShown, </ins> kbOpts: { primary: KeyMod.Alt | KeyCode.BracketRight, weight: KeybindingWeight.WorkbenchContrib


export const AccessibleViewPreviousAction = registerCommand(new MultiCommand({ id: 'editor.action.accessibleViewPrevious', <del> precondition: undefined, </del> <ins> precondition: accessibleViewIsShown, </ins> kbOpts: { primary: KeyMod.Alt | KeyCode.BracketLeft, weight: KeybindingWeight.WorkbenchContrib


import { localize } from 'vs/nls'; import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; <del> import { IContextKey, IContextKeyService, RawContextKey } from 'vs/platform/contextkey/common/contextkey'; </del> <ins> import { IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; </ins> import { IContextViewDelegate, IContextViewService } from 'vs/platform/contextview/browser/contextView'; import { IInstantiationService, createDecorator } from 'vs/platform/instantiation/common/instantiation'; import { IOpenerService } from 'vs/platform/opener/common/opener';


import { getSimpleEditorOptions } from 'vs/workbench/contrib/codeEditor/browser/simpleEditorOptions'; import { CodeActionController } from 'vs/editor/contrib/codeAction/browser/codeActionController'; import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; <del> import { AccessibilityVerbositySettingId, AccessibleViewAction, AccessibleViewNextAction, AccessibleViewPreviousAction } from 'vs/workbench/contrib/accessibility/browser/accessibilityContribution'; </del> <ins> import { AccessibilityVerbositySettingId, AccessibleViewAction, AccessibleViewNextAction, AccessibleViewPreviousAction, accessibilityHelpIsShown, accessibleViewIsShown } from 'vs/workbench/contrib/accessibility/browser/accessibilityContribution'; </ins> import { ILayoutService } from 'vs/platform/layout/browser/layoutService'; const enum DIMENSIONS {


type: AccessibleViewType; } <del> export const accessibilityHelpIsShown = new RawContextKey<boolean>('accessibilityHelpIsShown', false, true); export const accessibleViewIsShown = new RawContextKey<boolean>('accessibleViewIsShown', false, true); </del> class AccessibleView extends Disposable { private _editorWidget: CodeEditorWidget; private _accessiblityHelpIsShown: IContextKey<boolean>;


import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation'; import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility'; import { Action2, registerAction2 } from 'vs/platform/actions/common/actions'; <del> import { accessibilityHelpIsShown } from 'vs/workbench/contrib/accessibility/browser/accessibleView'; </del> <ins> import { accessibilityHelpIsShown } from 'vs/workbench/contrib/accessibility/browser/accessibilityContribution'; </ins> import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry'; import { KeyCode, KeyMod } from 'vs/base/common/keyCodes'; import { alert } from 'vs/base/browser/ui/aria/aria';


this.setHover(node.checkbox); this.setAccessibilityInformation(node.checkbox); this.toggle.domNode.classList.add(TreeItemCheckbox.checkboxClass); <ins> this.toggle.domNode.tabIndex = 1; </ins> DOM.append(this.checkboxContainer, this.toggle.domNode); this.registerListener(node); }


} async toggleAppliationScope(extension: ILocalExtension, fromProfileLocation: URI): Promise<ILocalExtension> { <del> if (isApplicationScopedExtension(extension.manifest)) { </del> <ins> if (isApplicationScopedExtension(extension.manifest) || extension.isBuiltin) { </ins> return extension; }


menu: { id: MenuId.ExtensionContext, group: '2_configure', <del> when: ContextKeyExpr.and(ContextKeyExpr.equals('extensionStatus', 'installed'), ContextKeyExpr.has('isDefaultApplicationScopedExtension').negate()), </del> <ins> when: ContextKeyExpr.and(ContextKeyExpr.equals('extensionStatus', 'installed'), ContextKeyExpr.has('isDefaultApplicationScopedExtension').negate(), ContextKeyExpr.has('isBuiltinExtension').negate()), </ins> order: 3 }, run: async (accessor: ServicesAccessor, id: string) => {


} async toggleApplyExtensionToAllProfiles(extension: IExtension): Promise<void> { <del> if (!extension.local || isApplicationScopedExtension(extension.local.manifest)) { </del> <ins> if (!extension.local || isApplicationScopedExtension(extension.local.manifest) || extension.isBuiltin) { </ins> return; } await this.extensionManagementService.toggleAppliationScope(extension.local, this.userDataProfileService.currentProfile.extensionsResource);


* Given the `repository.root` compute the relative path while trying to preserve * the casing of the resource URI. The `repository.root` segment of the path can * have a casing mismatch if the folder/workspace is being opened with incorrect <del> * casing. </del> <ins> * casing which is why we attempt to use substring() before relative(). </ins> */ export function relativePath(from: string, to: string): string { <del> // On Windows, there are cases in which `from` is a path that contains a trailing `` character // (ex: C:, serverfolder) due to the implementation of `path.normalize()`. This behavior is // by design as documented in https://github.com/nodejs/node/issues/1765. if (isWindows) { from = from.replace(/$/, ''); </del> <ins> // There are cases in which the `from` path may contain a trailing separator at // the end (ex: "C:", "serverfolder" (Windows) or "/" (Linux/macOS)) which // is by design as documented in https://github.com/nodejs/node/issues/1765. If // the trailing separator is missing, we add it. if (from.charAt(from.length - 1) !== sep) { from += sep; </ins> } if (isDescendant(from, to) && from.length < to.length) { <del> return to.substring(from.length + 1); </del> <ins> return to.substring(from.length); </ins> } // Fallback to `path.relative`


padding-right: 5px; /* with tab sizing shrink/fixed and badges, we want a right-padding because the close button is hidden */ } <ins> .monaco-workbench .part.editor > .content .editor-group-container > .title .tabs-container > .tab.sizing-shrink:not(.tab-actions-left):not(.tab-actions-off) .tab-label { padding-right: 5px; /* ensure that the gradient does not show when tab actions show https://github.com/microsoft/vscode/issues/189625*/ } </ins> .monaco-workbench .part.editor > .content .editor-group-container > .title .tabs-container > .tab.sticky-compact:not(.has-icon) .monaco-icon-label { text-align: center; /* ensure that sticky-compact tabs without icon have label centered */ }


/* Window Title Menu */ .monaco-workbench .part.titlebar > .titlebar-container > .titlebar-center > .window-title > .command-center { z-index: 2500; <del> } /* MacOS Desktop supports click event despite `drag` and therefore we don't need to clear it */ .monaco-workbench:not(.mac) .part.titlebar > .titlebar-container > .titlebar-center > .window-title > .command-center, .monaco-workbench.mac.web .part.titlebar > .titlebar-container > .titlebar-center > .window-title > .command-center { </del> -webkit-app-region: no-drag; }


} if (styles.listFocusForeground) { <del> content.push(`.monaco-list${suffix}:focus .monaco-list-row.focused:not(.monaco-list-row.action.option-disabled) { color: ${styles.listFocusForeground}; }`); </del> <ins> content.push(`.monaco-list${suffix}:focus .monaco-list-row.focused { color: ${styles.listFocusForeground}; }`); </ins> } if (styles.listActiveSelectionBackground) {


} .action-widget .monaco-list-row.action.option-disabled, <ins> .action-widget .monaco-list:focus .monaco-list-row.focused.action.option-disabled, </ins> .action-widget .monaco-list-row.action.option-disabled .codicon { color: var(--vscode-disabledForeground); } .action-widget .monaco-list-row.action:not(.option-disabled) .codicon { color: inherit; }


builtin printf '%s' "${terms[2]:-}" } <ins> __vsc_escape_value_fast() { builtin local LC_ALL=C out out=${1///} out=${out//;/x3b} builtin printf '%sn' "${out}" } </ins> # The property (P) and command (E) codes embed values which require escaping. # Backslashes are doubled. Non-alphanumeric characters are converted to escaped hex. __vsc_escape_value() { <ins> # If the input being too large, switch to the faster function if [ "${#1}" -ge 2000 ]; then __vsc_escape_value_fast "$1" builtin return fi </ins> # Process text byte by byte, not by codepoint. builtin local LC_ALL=C str="${1}" i byte token out=''


disturl "https://electronjs.org/headers" <del> target "25.9.2" ms_build_id "24603566" </del> <ins> target "25.9.4" ms_build_id "25127168" </ins> runtime "electron" build_from_source "true"


<del> 2606d6745056d248fe7ba21e6a30467d3ea80d2689c5fa6d2a35acf1b4a72ddd *chromedriver-v25.9.2-darwin-arm64.zip 22a86732b9e6c2afc07021ea0adeb92cdbaaa8751843c0d5170b5e96550685e7 *chromedriver-v25.9.2-darwin-x64.zip f5f42513bb55c7c1098e669d12488844ca2e63cd0d3a375db2eab517975c130c *chromedriver-v25.9.2-linux-arm64.zip 28a5613f7e4b117a65ec2882b124bf1d388f1c4fb86b228acadc297601faa6fd *chromedriver-v25.9.2-linux-armv7l.zip 7d01d537383df4b1653647e14fb768d27879943596a87b57ae3f171aa2aaf5d1 *chromedriver-v25.9.2-linux-x64.zip 3fac66fe45b4a5dcd9a4784d66bd8087d0dee5fccf06cb3f34e78f8bef3f0f8f *chromedriver-v25.9.2-mas-arm64.zip a15fc80fac243330f15a7ff7cc834c50c79833e81b871cc45f7239bf1743b4ac *chromedriver-v25.9.2-mas-x64.zip f0a354e01e277b14422e34f8af9c8c43ae975c6fb69a2e61ef275b6ec919f2ab *chromedriver-v25.9.2-win32-arm64.zip 570a6b5bc485bfea9681c97b79832d5d5bcafdd993c13dc4ab11558e3a27c554 *chromedriver-v25.9.2-win32-ia32.zip 4134f539ac304c65dfca9812b0d3943ea64d886989eba8f62828718b106c4eee *chromedriver-v25.9.2-win32-x64.zip 835418b9274c76503542c986d63bb9d98f071c702170536bdd62c1760589e01e *electron-api.json fd9f5b1439445acc69441ef66cc47f56c5c0848dec5f6daf91a476073e72a756 *electron-v25.9.2-darwin-arm64-dsym-snapshot.zip de29ef2a4c7b76281b1cf3ac9e6047a9275cc60167c6cd60509f2eb2a3258842 *electron-v25.9.2-darwin-arm64-dsym.zip 732f51802f2902ca08c3a06a45fe23820b1effbeb3ebd39fcae9fce5a1e0b25d *electron-v25.9.2-darwin-arm64-symbols.zip ab82efb59077a85fd20264f8ad0dedc4c8b0b2fc9d2948ed9461425faf5e35f6 *electron-v25.9.2-darwin-arm64.zip fb924b4dd0d781a14114e54fa556ca326c60665b674712c59163e7b44db675d8 *electron-v25.9.2-darwin-x64-dsym-snapshot.zip 197fc3e120e54578658e2f10b5fcec1d2004f1637d4bee116ff1e12b0c5a1429 *electron-v25.9.2-darwin-x64-dsym.zip 57d0a0f55726524ff843a040e516e425c3537a4602ab8c23120433fbc51470fb *electron-v25.9.2-darwin-x64-symbols.zip 0fe310e2ed13a97cd9c28fb0cf806338cd2e720083e6d1b13d60ba4cedb8f295 *electron-v25.9.2-darwin-x64.zip eb1a31ccd6a89a21538a8b1f0b5d3b77e1fe946b898319e1832cb9dc3abcd753 *electron-v25.9.2-linux-arm64-debug.zip b5b128bed0a09955ad5bb91fa9f5ab9155a547f787ad580bcd5bf409bb697ff6 *electron-v25.9.2-linux-arm64-symbols.zip 0b2d48a29d79fcd21d72d05fdb7638dd2fd257cf0d4cf9bd32f182b2634de466 *electron-v25.9.2-linux-arm64.zip eb1a31ccd6a89a21538a8b1f0b5d3b77e1fe946b898319e1832cb9dc3abcd753 *electron-v25.9.2-linux-armv7l-debug.zip 43f1f4c1475335719ba8f1f7f036a084fb22b5faa908bf4f7d30a96d5d9c159d *electron-v25.9.2-linux-armv7l-symbols.zip 4ea3ee3ad41c69454d9a12518eeff1ec5dbd841c8200dc8652e6c0b101d1259c *electron-v25.9.2-linux-armv7l.zip 1a8daf1f9e155d7143d16367e54e4e3b8e9d71ad580b44c8dfba0cb4e7a1c640 *electron-v25.9.2-linux-x64-debug.zip 803f32ca345d8974cc074dc177e06c62f8bcc98d4a39eccb676b7d302b8fc466 *electron-v25.9.2-linux-x64-symbols.zip aab65a562723e04eadbdee1251a749756b366dc1c5014bcc987c21c0a523fe2f *electron-v25.9.2-linux-x64.zip fd9f5b1439445acc69441ef66cc47f56c5c0848dec5f6daf91a476073e72a756 *electron-v25.9.2-mas-arm64-dsym-snapshot.zip 0ec88ec7bd2b7cb2e5e6b94f13df7d8c22433637004a473370e0959cb01f78cc *electron-v25.9.2-mas-arm64-dsym.zip 398a0575c1974565af99b6759a74967c0709bc101059542a00bfe64a1210a86f *electron-v25.9.2-mas-arm64-symbols.zip 17f86ad33f9fc2ca5eaac5ef87604e65b1eefba5a51d4ad58e70018fdfb84ac6 *electron-v25.9.2-mas-arm64.zip db61b29802ee1f598a3e61211a281656f16e70ae84041e6b2b5dd8ecae43cd67 *electron-v25.9.2-mas-x64-dsym-snapshot.zip 2f76620eb7d632335f7620f5d3713af5e59c98bdb0b323269c2319b7164fcaac *electron-v25.9.2-mas-x64-dsym.zip ea226c8d049e527d84ec5058474fd4e64476e6924fef42b1dbea774925f59064 *electron-v25.9.2-mas-x64-symbols.zip 51b9d192ccb7612211ca9cc8ddb373a86f791d38b369337ad099a133e9d9807a *electron-v25.9.2-mas-x64.zip 53b39857303191ea2f26dda06461e6e612ca0ed799bdf0c26a1a63ff89f7ea1b *electron-v25.9.2-win32-arm64-pdb.zip 49199591c69fbeb68dd57252a3d8525babe79ab98447ad639f2d0c3e63aba4b6 *electron-v25.9.2-win32-arm64-symbols.zip e7b968fc53cc7a10a4ccb5133af045968479685ebb9617f06817f03667fdd425 *electron-v25.9.2-win32-arm64-toolchain-profile.zip 6abd0a6697d7fe8b6add4d1017a01a0ac756d16da5bfa077bd373a685b529bd8 *electron-v25.9.2-win32-arm64.zip cc5c67b027c679eb86882c2ec267d38fafcc5127b49e8a060002541253e2b26b *electron-v25.9.2-win32-ia32-pdb.zip 2cd8aab8aa4eadfce90c8ba6565a77689db1efe55b7eaafedede3b08e8c41f53 *electron-v25.9.2-win32-ia32-symbols.zip e7b968fc53cc7a10a4ccb5133af045968479685ebb9617f06817f03667fdd425 *electron-v25.9.2-win32-ia32-toolchain-profile.zip ac2aebe7d7b21351256fb3b60219269e75ff33f8c3cfbbca682c3622d1943b94 *electron-v25.9.2-win32-ia32.zip 000b506bab92c92e0ff8428033fc7e1c15049437606794c4bec84a66eb29b6cd *electron-v25.9.2-win32-x64-pdb.zip fd40d04de0ef4a04dd720505f03a6d209a38387fe05493869f441037aa950e4d *electron-v25.9.2-win32-x64-symbols.zip e7b968fc53cc7a10a4ccb5133af045968479685ebb9617f06817f03667fdd425 *electron-v25.9.2-win32-x64-toolchain-profile.zip de3fc45f4fa5572d6dbb4f21580e75d3b6429a6b3b833a962c810e7e199b8573 *electron-v25.9.2-win32-x64.zip c3f22fbf99713bb44546278ef1456e4fc9a83d33bf038f6752fea12c7a721337 *electron.d.ts 2a088f4c227405783466e456e69154193a730130f5cc39520091abc8993977bc *ffmpeg-v25.9.2-darwin-arm64.zip 4da4197282a9a31379d2194d1072888b9ed3200663e322df2759b971725a2915 *ffmpeg-v25.9.2-darwin-x64.zip bd52d57ff97fb56ac01a3482af905d04f0d4e9c13c53858c6d9f99957eca82da *ffmpeg-v25.9.2-linux-arm64.zip 9b3d09177fa1e63e2a6beecfa70aeec30aeb5c1873ff21128a68051c4e23f95d *ffmpeg-v25.9.2-linux-armv7l.zip 39c3e411873262873edff4b9f4b5d9973fb3cab8f700d6ff665872dab3b39eb3 *ffmpeg-v25.9.2-linux-x64.zip 861287a6cb0f546c0e39f49a2b28f5575d66fbddb26486584cc7802e84402339 *ffmpeg-v25.9.2-mas-arm64.zip bcc8315a9e07394510c96ffca20720e3cdb2a4aecc75798bfca8fd60417782aa *ffmpeg-v25.9.2-mas-x64.zip 0ebfe5a72aaf0a9af81ffbcba03763f4baa142c93c31b50ad0145365366f0076 *ffmpeg-v25.9.2-win32-arm64.zip d8e7ea1268145d3481a74152ced8ae677ca5b174f06eb874a6ce0005ff0d471c *ffmpeg-v25.9.2-win32-ia32.zip d1f499b957377c3822c43eadf3bc32e7cb04b52fb2fd51ba22f14cd61ef01727 *ffmpeg-v25.9.2-win32-x64.zip 86a0df1394e741feb21a891747775911d5c2f9cd940662826b33c309275abb7c *hunspell_dictionaries.zip 4c4bab279b39c4e463dcb3a897e256e5e4f088e6e6495f6aea10e26703ecafc3 *libcxx-objects-v25.9.2-linux-arm64.zip d2b6349a89c9fce3ccc0a9a430b059eb18cd3967dbbe34bfcae54b3f58cd462a *libcxx-objects-v25.9.2-linux-armv7l.zip e8d4b1a3228c0709dc54d780bd4d33727fff30c38f8e00409a6eaf54a69e5869 *libcxx-objects-v25.9.2-linux-x64.zip 7679259e7cb02140806cc616d012102462d671ae07c4673ad0c2c9a6716444a6 *libcxx_headers.zip b1683af6708bceaa966e5168fda51223fa51e09549abc90f5744d500f9260c92 *libcxxabi_headers.zip 4fed33611a889d0100a6fbf4253cf9dcb9fbe3c42f7c86d8886d460a9a9cf8e6 *mksnapshot-v25.9.2-darwin-arm64.zip 5e1daea6393bd977a70020c36f1e4ee4e416c8c4eafe2b27b38292e4acb1764b *mksnapshot-v25.9.2-darwin-x64.zip 92ff719eb83df7f107d4dd3970122333f4bde194292c568b5c0a5ea4684bc9f1 *mksnapshot-v25.9.2-linux-arm64-x64.zip e621d50652f2afa49f47ab7cccd07f7d29ef60f694a0e70d4e6434ddd07cf282 *mksnapshot-v25.9.2-linux-armv7l-x64.zip 012c24dd59f7b5b4322e53c12bb6450a7b15bc6800042fcf3804ba14685f8188 *mksnapshot-v25.9.2-linux-x64.zip 62e880bf8594b1d83926984c252d86990f1386655bd1375afc0fd3054018adef *mksnapshot-v25.9.2-mas-arm64.zip 0742e1bfcbe171199f0a333fddbf401a61777928d462b852d21fec2822b2c46e *mksnapshot-v25.9.2-mas-x64.zip b019e6e117e13238465d1758274ebbaf7ccb999921dcb11ef1e3a9a5a6df952b *mksnapshot-v25.9.2-win32-arm64-x64.zip bc7196f1fd2ba3aedc6c16e96e455d280155dfc493a0d0f6ce7bffe645e39e1e *mksnapshot-v25.9.2-win32-ia32.zip 2d152f09969d69439e831b4212e77ea157a9e4b3a9b3ad55d4f2efcc547c25eb *mksnapshot-v25.9.2-win32-x64.zip </del>  No newline at end of file <ins> 004cb2a93a7094449675ac49998f1c1572dd74b7839039332525f44a2a4d6905 *chromedriver-v25.9.4-darwin-arm64.zip e578c2b7c88ae066664c0562ca77f776d419a6ae5045383df9718e743147f880 *chromedriver-v25.9.4-darwin-x64.zip 7c0f030cf143d682ae838e078d560b76b5f0af8c65d67f6026167c0a04c8f60b *chromedriver-v25.9.4-linux-arm64.zip 320026f620bdd708aff88c97ee9bf40d2fbad4fce4be0be3c8252876c9a629ec *chromedriver-v25.9.4-linux-armv7l.zip 65d4473294f024e4ba56a72ba9f87bec51207a7c924fda998acf499e5db4da9c *chromedriver-v25.9.4-linux-x64.zip 191ba934dace5851f60ec5cdb040202dacebf837ae6b8483649cc85da698ffeb *chromedriver-v25.9.4-mas-arm64.zip 1da9b56db091b1825cb3913de5eb12e30bb55f55023e044bed9e6d1518ab86f7 *chromedriver-v25.9.4-mas-x64.zip 3efd22a6d4500603f629f5c58af44570909df6871eccc9d17c01d04ab17ca47e *chromedriver-v25.9.4-win32-arm64.zip cd8b4be4d491f39aebc97102e2a48e43260eff693163c1526f1fb0b401ec0a81 *chromedriver-v25.9.4-win32-ia32.zip 03df2f38e3a07f70b766a5f0a9548acf8b35148dcb97d12e0479fd527da423e3 *chromedriver-v25.9.4-win32-x64.zip f1c4c82db5b9649d7e9cdb4c482a76ded439f6b11267f4b5eb869616a7f8244a *electron-api.json ac61c1f78f4bebf74073b4dbca356bc3aef6b44b4b069f8f2bfdb03d562e50f9 *electron-v25.9.4-darwin-arm64-dsym-snapshot.zip 54424b0db7f38794dbc5aff1bf3a20fc93f0f35a03fce8eaaf523bbc075fef83 *electron-v25.9.4-darwin-arm64-dsym.zip 1d816ad4c6a6e198d8ae6bb49698982f0f0298a605db09d46d3d4509c16a84a1 *electron-v25.9.4-darwin-arm64-symbols.zip 8022153ed1437a5785a0f819d14f41ae1026c1c5c1406d535a32c2a0ec1e4ba3 *electron-v25.9.4-darwin-arm64.zip 1a76a3c9ef80989488ed5a5cb9d4f54d284f79931f98907e6dbe3437271b33c0 *electron-v25.9.4-darwin-x64-dsym-snapshot.zip 92b14aa0a6dbbf9dd4829464ecea4ee77536f6c45cd393aa00b502eb5d72e480 *electron-v25.9.4-darwin-x64-dsym.zip 0bd268108df307e6d7770fea8882b5072ced5da23a0914e3e660e26c80314174 *electron-v25.9.4-darwin-x64-symbols.zip 4a3b55cfdb3fedbe188f51c552ffa1f9d17d145926990ca914faccbb72634ee6 *electron-v25.9.4-darwin-x64.zip 59bde360b480228cb166836d678682146d6f4cf9c8e6a534087c974e827b11bb *electron-v25.9.4-linux-arm64-debug.zip c8a2174ddfa18eeb326c830cbaf944931038de422d7e8492a9a5680dd54c77eb *electron-v25.9.4-linux-arm64-symbols.zip 119481d318dec273434f9f4f43fb808ff66858cc0da1f17deccc6b08a99fbb83 *electron-v25.9.4-linux-arm64.zip 59bde360b480228cb166836d678682146d6f4cf9c8e6a534087c974e827b11bb *electron-v25.9.4-linux-armv7l-debug.zip f791ce6c4bfe8ae7a00df9ac9dad766ce5ac4e502092b02c0361327a84ac07a8 *electron-v25.9.4-linux-armv7l-symbols.zip 2ef1673f4c6b943b35dc1dd3379aae7534f2456c91eabc704e2db35012aac706 *electron-v25.9.4-linux-armv7l.zip ff0e6cd86b963d87edd02202284e1fd29842f5fa85b4ca7a21ab753507ab3a9d *electron-v25.9.4-linux-x64-debug.zip add83741ede569ec1ed243aea8a77d782674a59c62221a4b9bd07507af62441e *electron-v25.9.4-linux-x64-symbols.zip 84f92675e3a9616cc163de673ebfafaad3c2976dc500612875a23849bc3661ce *electron-v25.9.4-linux-x64.zip ac61c1f78f4bebf74073b4dbca356bc3aef6b44b4b069f8f2bfdb03d562e50f9 *electron-v25.9.4-mas-arm64-dsym-snapshot.zip a76831375f19b4d48766211026446f2b073247c1e1a29edb52683caa0d0fc349 *electron-v25.9.4-mas-arm64-dsym.zip 5a8a82ac24fdd31389391a157509b0a45e23d7e70236968b7b4a2130d930d04f *electron-v25.9.4-mas-arm64-symbols.zip c7e47d78ee8fc6d9112a38977cf1ebbec31cdf06b8a0540f120e7a69500c56f7 *electron-v25.9.4-mas-arm64.zip 94253d587d9ed00b1741a64ca36e32fe8bc60cc32df48675bef89af081c4f0ec *electron-v25.9.4-mas-x64-dsym-snapshot.zip bf6e83d683c7fb88e21b93d4926b1e3dc9151f94e1bb4635ae2b77992b2c6598 *electron-v25.9.4-mas-x64-dsym.zip 4b9758d4a74e21f66eedb95392d098e057e509a1f0eecc09729fa36747918838 *electron-v25.9.4-mas-x64-symbols.zip 6e26f31b8088563b2cc4d1552d9ff00e61bc7ef1b95b7cfe404564f84b5b210d *electron-v25.9.4-mas-x64.zip c6fe73f028eff3dfdd6408b8762b5e0d2a67b3bd110b5910d1bec1fa85da8a5a *electron-v25.9.4-win32-arm64-pdb.zip ccccad00e4e16048743d5252023665b74ab804a7482606dc0dc9ad01f94c988b *electron-v25.9.4-win32-arm64-symbols.zip e7b968fc53cc7a10a4ccb5133af045968479685ebb9617f06817f03667fdd425 *electron-v25.9.4-win32-arm64-toolchain-profile.zip 667c212b51400bfd1ab78a83d2adcdd6c9624a71b1a6892432e38ce9658d8093 *electron-v25.9.4-win32-arm64.zip 320dab9a57c4f0efa1ecadb4a07ec15adecaa913ef62524cacaa9f011292571f *electron-v25.9.4-win32-ia32-pdb.zip 2875e171ebba7fc12be3133cabbd38cdca30d3cedbb89a1e1e11270380b4afc5 *electron-v25.9.4-win32-ia32-symbols.zip e7b968fc53cc7a10a4ccb5133af045968479685ebb9617f06817f03667fdd425 *electron-v25.9.4-win32-ia32-toolchain-profile.zip 18b11abf7b1f2f4568c3cf5dc9a2a0fc5349b6e3f40ecb91e086b030f254510d *electron-v25.9.4-win32-ia32.zip a4b49fee1139071eb33c014ed8ac49cf83065a6d95255c44acc78c3922c56185 *electron-v25.9.4-win32-x64-pdb.zip 1712567ed6b050501a974e33a9a46cd806965d73b36ec8e18346d49022f74a8a *electron-v25.9.4-win32-x64-symbols.zip e7b968fc53cc7a10a4ccb5133af045968479685ebb9617f06817f03667fdd425 *electron-v25.9.4-win32-x64-toolchain-profile.zip 03abc9d5b2b28b440e9e5b0fc61806e3f3c2888dac5d5939957726bd68955113 *electron-v25.9.4-win32-x64.zip 706c40b11144551b2da43cdfd191c2e3e2bf0d7600b8d2751f3a806f72d0ede2 *electron.d.ts 859e7f8f6b6faf1fd004ef335ccff6f25f18c17f1aa63031e0af238899513958 *ffmpeg-v25.9.4-darwin-arm64.zip 3b63d30acb2bc5cdcc94ac2dc9e69e0919bf5038d3fd61f822c183280684cc4e *ffmpeg-v25.9.4-darwin-x64.zip bd52d57ff97fb56ac01a3482af905d04f0d4e9c13c53858c6d9f99957eca82da *ffmpeg-v25.9.4-linux-arm64.zip 9b3d09177fa1e63e2a6beecfa70aeec30aeb5c1873ff21128a68051c4e23f95d *ffmpeg-v25.9.4-linux-armv7l.zip edc7b1c9f1a0733f109a2c0375a4e40c5bfe0bf28b7f06dcc76e1ada0aa2f125 *ffmpeg-v25.9.4-linux-x64.zip dae4d7857e7cf2d1333ce522ed3c8e3639a95432015a649a6cc3d064ddc076eb *ffmpeg-v25.9.4-mas-arm64.zip b2d9a72f57a18c68c30cbbde305ba91e740656746e37d5ce22e8895e7ec36a74 *ffmpeg-v25.9.4-mas-x64.zip 7ebbd70835b6bbd1d12e432a2b0df4fb5fccd4039c6b5125401069b1c0ff6f0e *ffmpeg-v25.9.4-win32-arm64.zip 128499e322306bf4900106d1120e28d93cafd7af5c5052109f2739360c7e212a *ffmpeg-v25.9.4-win32-ia32.zip 00a2e9d9b783899662b430feb5fb030e89ae7682ef4e3bf8eb4c8ecbfd435b84 *ffmpeg-v25.9.4-win32-x64.zip 1b9943e151314644652f738afa309d1d4f3cb18fc505e568c1f80e66e0ccf1b3 *hunspell_dictionaries.zip 631aac564c555332dbf9d7acdcce6852c594cd84d3afd3056e738c64f4b1cb1b *libcxx-objects-v25.9.4-linux-arm64.zip 4ad907d1b04bb93aba78b086ffdf16e2c0aa23f5a3901ad23ab4fd1aa46e80a3 *libcxx-objects-v25.9.4-linux-armv7l.zip c8950fb9555c33015cb0d2299dfb2b35daa1c0c7d392bf53a96f570b8c064c93 *libcxx-objects-v25.9.4-linux-x64.zip aaafbf6dfc756d3244d6085c419eec5dc3aa7b12face8a0bab1733aed3e7f3e7 *libcxx_headers.zip c571e713663bdc68f5956e45b975b89bd23cc2e401a1161321167d224b1dea3d *libcxxabi_headers.zip cf42b5f0e4e6500b89ab8313267a459584be8a175cc6c7e20c1fee50277c65f4 *mksnapshot-v25.9.4-darwin-arm64.zip 6f1b74306d691214218e2894f813af1d0fde5e6ded31ad94c1ad4f44b4582b29 *mksnapshot-v25.9.4-darwin-x64.zip 9a0e09332db556357288b46738a409269cc4c83816396c70fd5b518548eb884d *mksnapshot-v25.9.4-linux-arm64-x64.zip 80692a923553ae0172f5a981ff44d7194a307d826be5c39473f2555c1af4a025 *mksnapshot-v25.9.4-linux-armv7l-x64.zip 6dfb2d094b96f8507b4984ad8dcb14c56a8df5cd5bf89533ff6c7714009da4a0 *mksnapshot-v25.9.4-linux-x64.zip 50c800e3aa75997ec377e3d91682f9f4b49dd4e95555dd9acbbdd083d73718ac *mksnapshot-v25.9.4-mas-arm64.zip 81ea7704f3453c6d8e55525dd7e2999664e45002dab70dd250b2194b6ddccc7c *mksnapshot-v25.9.4-mas-x64.zip e817d7637498531c4de3bcbdfbd45a6255f04e349b2aa8ffdf454817f2c78b54 *mksnapshot-v25.9.4-win32-arm64-x64.zip f61be226a7c303d1b2502561de5093b0a9d364ae6d0a3b51d9c1d8b793ac97ef *mksnapshot-v25.9.4-win32-ia32.zip 73c65b7356aa3d703ca8ca43ec2436ee9c9475ce8b27b71b4313c0b3d4d76e10 *mksnapshot-v25.9.4-win32-x64.zip </ins>  No newline at end of file


"git": { "name": "electron", "repositoryUrl": "https://github.com/electron/electron", <del> "commitHash": "468c4af6611c88762b7ba6c4400c5022895457c2" </del> <ins> "commitHash": "bb6a7d443b4f00680d05cc703b4d7ae180fdde03" </ins> } }, "isOnlyProductionDependency": true, "license": "MIT", <del> "version": "25.9.2" </del> <ins> "version": "25.9.4" </ins> }, { "component": {


{ "name": "code-oss-dev", "version": "1.85.0", <del> "distro": "cbc81496e34eafbc771b8f008e6a742d755968c9", </del> <ins> "distro": "210db50a0928d4857ed3d511ddb5612b947e0fef", </ins> "author": { "name": "Microsoft Corporation" },


"cssnano": "^4.1.11", "debounce": "^1.0.0", "deemon": "^1.8.0", <del> "electron": "25.9.2", </del> <ins> "electron": "25.9.4", </ins> "eslint": "8.36.0", "eslint-plugin-header": "3.1.1", "eslint-plugin-jsdoc": "^46.5.0",


disturl "https://nodejs.org/dist" target "18.15.0" <del> ms_build_id "234519" </del> <ins> ms_build_id "243295" </ins> runtime "node" build_from_source "true"


resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.207.tgz#9c3310ebace2952903d05dcaba8abe3a4ed44c01" integrity sha512-piH7MJDJp4rJCduWbVvmUd59AUne1AFBJ8JaRQvk0KzNTSUnZrVXHCZc+eg+CGE4OujkcLJznhGKD6tuAshj5Q== <del> electron@25.9.2: version "25.9.2" resolved "https://registry.yarnpkg.com/electron/-/electron-25.9.2.tgz#12be98fbcff485c94ff99df21e0727797a45364a" integrity sha512-hVBN5rsrL99BKNHvzMeYy2PkAmewuIobu4U3o3EzVz4MDoLmMfW4yTH5GZ4RbJrpokoEky5IzGtRR/ggPzL6Fw== </del> <ins> electron@25.9.4: version "25.9.4" resolved "https://registry.yarnpkg.com/electron/-/electron-25.9.4.tgz#1935b6fbfd8ad920719a4136d867021496703884" integrity sha512-5pDU8a7o7ZIPTZHAqjflGMq764Favdsc271KXrAT3oWvFTHs5Ve9+IOt5EUVPrwvC2qRWKpCIEM47WzwkTlENQ== </ins> dependencies: "@electron/get" "^2.0.0" "@types/node" "^18.11.18"


import { IRemoteSocketFactoryService } from 'vs/platform/remote/common/remoteSocketFactoryService'; import { ISignService } from 'vs/platform/sign/common/sign'; import { AbstractTunnelService, ISharedTunnelsService, ITunnelProvider, ITunnelService, RemoteTunnel, TunnelPrivacyId, isAllInterfaces, isLocalhost, isPortPrivileged, isTunnelProvider } from 'vs/platform/tunnel/common/tunnel'; <ins> import { VSBuffer } from 'vs/base/common/buffer'; </ins> async function createRemoteTunnel(options: IConnectionOptions, defaultTunnelHost: string, tunnelRemoteHost: string, tunnelRemotePort: number, tunnelLocalPort?: number): Promise<RemoteTunnel> { let readyTunnel: NodeRemoteTunnel | undefined;


remoteSocket.onClose(() => localSocket.destroy()); remoteSocket.onEnd(() => localSocket.end()); remoteSocket.onData(d => localSocket.write(d.buffer)); <ins> localSocket.on('data', d => remoteSocket.write(VSBuffer.wrap(d))); </ins> localSocket.resume(); }


import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { InstantiationType, registerSingleton } from 'vs/platform/instantiation/common/extensions'; import { ISemanticSimilarityService } from 'vs/workbench/services/semanticSimilarity/common/semanticSimilarityService'; <ins> import { IAiRelatedInformationService, RelatedInformationType, SettingInformationResult } from 'vs/workbench/services/aiRelatedInformation/common/aiRelatedInformation'; </ins> export interface IEndpointDetails { urlBase?: string;


private settingsRecord: Record<string, ISetting> = {}; private currentPreferencesModel: ISettingsEditorModel | undefined; <del> constructor(private readonly semanticSimilarityService: ISemanticSimilarityService) { } </del> <ins> constructor( private readonly aiRelatedInformationService: IAiRelatedInformationService, private readonly semanticSimilarityService: ISemanticSimilarityService ) { } </ins> updateModel(preferencesModel: ISettingsEditorModel) { if (preferencesModel === this.currentPreferencesModel) {


this.settingKeys = []; this.settingsRecord = {}; <del> if (!this.semanticSimilarityService.isEnabled() || !this.currentPreferencesModel) { </del> <ins> if ( !this.currentPreferencesModel || (!this.semanticSimilarityService.isEnabled() && !this.aiRelatedInformationService.isEnabled()) ) { </ins> return; }


constructor( @ISemanticSimilarityService private readonly semanticSimilarityService: ISemanticSimilarityService, <ins> @IAiRelatedInformationService private readonly aiRelatedInformationService: IAiRelatedInformationService </ins> ) { <del> this._keysProvider = new RemoteSearchKeysProvider(semanticSimilarityService); </del> <ins> this._keysProvider = new RemoteSearchKeysProvider(aiRelatedInformationService, semanticSimilarityService); </ins> } setFilter(filter: string) {


} async searchModel(preferencesModel: ISettingsEditorModel, token?: CancellationToken | undefined): Promise<ISearchResult | null> { <del> if (!this.semanticSimilarityService.isEnabled() || !this._filter) { </del> <ins> if ( !this._filter || (!this.semanticSimilarityService.isEnabled() && !this.aiRelatedInformationService.isEnabled())) { </ins> return null; } this._keysProvider.updateModel(preferencesModel); <ins> const filterMatches = this.aiRelatedInformationService.isEnabled() ? await this.getAiRelatedInformationItems(token) : this.semanticSimilarityService.isEnabled() ? await this.getSemanticSimilarityItems(token) : []; return { filterMatches }; } // TODO: Remove this when all semantic similarity providers are migrated to aiRelatedInformationService private async getSemanticSimilarityItems(token?: CancellationToken | undefined) { </ins> const settingKeys = this._keysProvider.getSettingKeys(); const settingsRecord = this._keysProvider.getSettingsRecord();


}); numOfSmartPicks++; } <del> return { filterMatches }; </del> <ins> return filterMatches; } private async getAiRelatedInformationItems(token?: CancellationToken | undefined) { const settingsRecord = this._keysProvider.getSettingsRecord(); const filterMatches: ISettingMatch[] = []; const relatedInformation = await this.aiRelatedInformationService.getRelatedInformation(this._filter, [RelatedInformationType.SettingInformation], token ?? CancellationToken.None) as SettingInformationResult[]; relatedInformation.sort((a, b) => b.weight - a.weight); for (const info of relatedInformation) { if (info.weight < RemoteSearchProvider.SEMANTIC_SIMILARITY_THRESHOLD || filterMatches.length === RemoteSearchProvider.SEMANTIC_SIMILARITY_MAX_PICKS) { break; } const pick = info.setting; filterMatches.push({ setting: settingsRecord[pick], matches: [settingsRecord[pick].range], matchType: SettingMatchType.RemoteMatch, score: info.weight }); } return filterMatches; </ins> } }


command: string; } <ins> export interface SettingInformationResult extends RelatedInformationResult { type: RelatedInformationType.SettingInformation; setting: string; } </ins> export interface IAiRelatedInformationService { readonly _serviceBrand: undefined;


import { StopWatch } from 'vs/base/common/stopwatch'; import { ILogService } from 'vs/platform/log/common/log'; <ins> /** * @deprecated Use `IAiRelatedInformationService` instead. */ </ins> export const ISemanticSimilarityService = createDecorator<ISemanticSimilarityService>('ISemanticSimilarityService'); <ins> /** * @deprecated Use `IAiRelatedInformationService` instead. */ </ins> export interface ISemanticSimilarityService { readonly _serviceBrand: undefined;


private _readConfiguration() { const options = this._editor.getOption(EditorOption.stickyScroll); if (options.enabled === false) { this._editor.removeOverlayWidget(this._stickyScrollWidget); this._sessionStore.clear();


} private _renderStickyScroll() { <del> if (!(this._editor.hasModel())) { </del> <ins> const model = this._editor.getModel(); if (!model || model.isTooLargeForTokenization()) { this._stickyScrollWidget.setState(undefined); </ins> return; } <del> const model = this._editor.getModel(); </del> const stickyLineVersion = this._stickyLineCandidateProvider.getVersionId(); if (stickyLineVersion === undefined || stickyLineVersion === model.getVersionId()) { this._widgetState = this.findScrollWidgetState();


return this._lineNumbers; } <del> setState(state: StickyScrollWidgetState): void { dom.clearNode(this._lineNumbersDomNode); dom.clearNode(this._linesDomNode); </del> <ins> setState(state: StickyScrollWidgetState | undefined): void { this._clearStickyWidget(); if (!state) { return; } </ins> this._stickyLines = []; const editorLineHeight = this._editor.getOption(EditorOption.lineHeight); const futureWidgetHeight = state.startLineNumbers.length * editorLineHeight + state.lastLineRelativePosition;


this._rootDomNode.style.width = `${layoutInfo.width - layoutInfo.minimap.minimapCanvasOuterWidth - layoutInfo.verticalScrollbarWidth}px`; } <ins> private _clearStickyWidget() { dom.clearNode(this._lineNumbersDomNode); dom.clearNode(this._linesDomNode); this._rootDomNode.style.display = 'none'; } </ins> private _renderRootNode(): void { if (!this._editor._getViewModel()) {


const editorLineHeight = this._editor.getOption(EditorOption.lineHeight); const widgetHeight: number = this._lineNumbers.length * editorLineHeight + this._lastLineRelativePosition; <del> this._rootDomNode.style.display = widgetHeight > 0 ? 'block' : 'none'; </del> <ins> if (widgetHeight === 0) { this._clearStickyWidget(); return; } this._rootDomNode.style.display = 'block'; </ins> this._lineNumbersDomNode.style.height = `${widgetHeight}px`; this._linesDomNodeScrollable.style.height = `${widgetHeight}px`; this._rootDomNode.style.height = `${widgetHeight}px`;


'Variable 0 will be a file name.' ] }, <del> "{0}: tokenization, wrapping and folding have been turned off for this large file in order to reduce memory usage and avoid freezing or crashing.", </del> <ins> "{0}: tokenization, wrapping, folding and sticky scroll have been turned off for this large file in order to reduce memory usage and avoid freezing or crashing.", </ins> path.basename(model.uri.path) );


import { memoize } from 'vs/base/common/decorators'; import { join } from 'vs/base/common/path'; import { isLinux } from 'vs/base/common/platform'; <ins> import { URI } from 'vs/base/common/uri'; </ins> import { createStaticIPCHandle } from 'vs/base/parts/ipc/node/ipc.net'; import { IEnvironmentService, INativeEnvironmentService } from 'vs/platform/environment/common/environment'; import { NativeEnvironmentService } from 'vs/platform/environment/node/environmentService';


@memoize get useCodeCache(): boolean { return !!this.codeCachePath; } <ins> @memoize override get userRoamingDataHome(): URI { return this.appSettingsHome; } </ins> unsetSnapExportedVariables() { if (!isLinux) { return;


"title": "%cleanInvalidImageAttachment.title%" }, { <del> "command": "notebook.cellOutput.copyToClipboard", "title": "%copyOutputToClipboard.title%" </del> <ins> "command": "notebook.cellOutput.copy", "title": "%copyCellOutput.title%" </ins> } ], "notebooks": [


], "webview/context": [ { <del> "command": "notebook.cellOutput.copyToClipboard", </del> <ins> "command": "notebook.cellOutput.copy", </ins> "when": "webviewId == 'notebook.output' && webviewSection == 'image'" } ]


"newUntitledIpynb.shortTitle": "Jupyter Notebook", "openIpynbInNotebookEditor.title": "Open IPYNB File In Notebook Editor", "cleanInvalidImageAttachment.title": "Clean Invalid Image Attachment Reference", <del> "copyOutputToClipboard.title": "Copy Output to Clipboard", </del> <ins> "copyCellOutput.title": "Copy Output", </ins> "markdownAttachmentRenderer.displayName": { "message": "Markdown-It ipynb Cell Attachment renderer", "comment": [


import { CellKind } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { CodeCellViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel'; <del> export const COPY_OUTPUT_COMMAND_ID = 'notebook.cellOutput.copyToClipboard'; </del> <ins> export const COPY_OUTPUT_COMMAND_ID = 'notebook.cellOutput.copy'; </ins> registerAction2(class CopyCellOutputAction extends Action2 { constructor() { super({ id: COPY_OUTPUT_COMMAND_ID, <del> title: localize('notebookActions.copyOutput', "Copy Output to Clipboard"), </del> <ins> title: localize('notebookActions.copyOutput', "Copy Output"), </ins> menu: { id: MenuId.NotebookOutputToolbar, when: NOTEBOOK_CELL_HAS_OUTPUTS


'application/x.notebook.stream', 'application/vnd.code.notebook.stderr', 'application/x.notebook.stderr', <del> 'text/plain' </del> <ins> 'text/plain', 'text/markdown', 'application/json' </ins> ];


this._loadState(); this._register(this._storageService.onWillSaveState(() => this._saveState())); this._register(this._storageService.onDidChangeValue(StorageScope.WORKSPACE, NotebookKernelHistoryService.STORAGE_KEY, this._register(new DisposableStore()))(() => { <del> this._restoreState(); </del> <ins> this._loadState(); </ins> })); }


} } <del> private _restoreState(): void { const serialized = this._storageService.get(NotebookKernelHistoryService.STORAGE_KEY, StorageScope.WORKSPACE); if (serialized) { try { for (const [viewType, kernels] of JSON.parse(serialized)) { const linkedMap = this._mostRecentKernelsMap[viewType] ?? new LinkedMap<string, string>(); for (const entry of kernels.entries) { linkedMap.set(entry, entry, Touch.AsOld); } this._mostRecentKernelsMap[viewType] = linkedMap; } } catch (e) { console.error('Deserialize notebook kernel history failed', e); } } } </del> private _loadState(): void { const serialized = this._storageService.get(NotebookKernelHistoryService.STORAGE_KEY, StorageScope.WORKSPACE); if (serialized) {


import { workspace, window, languages, commands, ExtensionContext, extensions, Uri, ColorInformation, Diagnostic, StatusBarAlignment, TextEditor, TextDocument, FormattingOptions, CancellationToken, FoldingRange, <del> ProviderResult, TextEdit, Range, Position, Disposable, CompletionItem, CompletionList, CompletionContext, Hover, MarkdownString, FoldingContext, DocumentSymbol, SymbolInformation, l10n, TextEditorOptions </del> <ins> ProviderResult, TextEdit, Range, Position, Disposable, CompletionItem, CompletionList, CompletionContext, Hover, MarkdownString, FoldingContext, DocumentSymbol, SymbolInformation, l10n </ins> } from 'vscode'; import { LanguageClientOptions, RequestType, NotificationType, FormattingOptions as LSPFormattingOptions,


export namespace SettingIds { export const enableFormatter = 'json.format.enable'; export const enableKeepLines = 'json.format.keepLines'; <del> export const enableSortOnSave = 'json.sortOnSave.enable'; </del> export const enableValidation = 'json.validate.enable'; export const enableSchemaDownload = 'json.schemaDownload.enable'; export const maxItemsComputed = 'json.maxItemsComputed';


window.showInformationMessage(l10n.t('JSON schema cache cleared.')); })); <del> toDispose.push(workspace.onWillSaveTextDocument(event => { const sortOnSave = workspace.getConfiguration().get<boolean>(SettingIds.enableSortOnSave); const document = event.document; if (sortOnSave && (document.languageId === 'json' || document.languageId === 'jsonc')) { const documentOptions = getOptionsForDocument(document); const textEditsPromise = getSortTextEdits(document, documentOptions?.tabSize, documentOptions?.insertSpaces); event.waitUntil(textEditsPromise); } })); </del> toDispose.push(commands.registerCommand('json.sort', async () => {


function isSchemaResolveError(d: Diagnostic) { return d.code === /* SchemaResolveError */ 0x300; } <del> function getOptionsForDocument(document: TextDocument): TextEditorOptions | undefined { for (const editor of window.visibleTextEditors) { if (editor.document.uri.toString() === document.uri.toString()) { return editor.options; } } return; } </del>


"default": false, "description": "%json.format.keepLines.desc%" }, <del> "json.sortOnSave.enable": { "type": "boolean", "scope": "window", "default": false, "description": "%json.sortOnSave.enable.desc%" }, </del> "json.trace.server": { "type": "string", "scope": "window",


"json.schemas.schema.desc": "The schema definition for the given URL. The schema only needs to be provided to avoid accesses to the schema URL.", "json.format.enable.desc": "Enable/disable default JSON formatter", "json.format.keepLines.desc" : "Keep all existing new lines when formatting.", <del> "json.sortOnSave.enable.desc": "Enable/disable default sorting on save", </del> "json.validate.enable.desc": "Enable/disable JSON validation.", "json.tracing.desc": "Traces the communication between VS Code and the JSON language server.", "json.colorDecorators.enable.desc": "Enables or disables color decorators",


import { Connection, TextDocuments, InitializeParams, InitializeResult, NotificationType, RequestType, <del> DocumentRangeFormattingRequest, Disposable, ServerCapabilities, TextDocumentSyncKind, TextEdit, DocumentFormattingRequest, TextDocumentIdentifier, FormattingOptions, Diagnostic </del> <ins> DocumentRangeFormattingRequest, Disposable, ServerCapabilities, TextDocumentSyncKind, TextEdit, DocumentFormattingRequest, TextDocumentIdentifier, FormattingOptions, Diagnostic, CodeAction, CodeActionKind </ins> } from 'vscode-languageserver'; import { runSafe, runSafeAsync } from './utils/runner';


import { TextDocument, JSONDocument, JSONSchema, getLanguageService, DocumentLanguageSettings, SchemaConfiguration, ClientCapabilities, Range, Position, SortOptions } from 'vscode-json-languageservice'; import { getLanguageModelCache } from './languageModelCache'; import { Utils, URI } from 'vscode-uri'; <ins> import * as l10n from '@vscode/l10n'; </ins> type ISchemaAssociations = Record<string, string[]>;


documentSelector: null, interFileDependencies: false, workspaceDiagnostics: false <del> } </del> <ins> }, codeActionProvider: true </ins> }; return { capabilities };


}, [], `Error while computing document symbols for ${documentSymbolParams.textDocument.uri}`, token); }); <ins> connection.onCodeAction((codeActionParams, token) => { return runSafeAsync(runtime, async () => { const document = documents.get(codeActionParams.textDocument.uri); if (document) { const sortCodeAction = CodeAction.create('Sort JSON', CodeActionKind.Source.concat('.sort', '.json')); sortCodeAction.command = { command: 'json.sort', title: l10n.t('Sort JSON') }; return [sortCodeAction]; } return []; }, [], `Error while computing code actions for ${codeActionParams.textDocument.uri}`, token); }); </ins> function onFormat(textDocument: TextDocumentIdentifier, range: Range | undefined, options: FormattingOptions): TextEdit[] { options.keepLines = keepLinesEnabled;


const startN = binarySearch2(da.length, i => Number(da.row(i).address - firstAddr)); const start = startN < 0 ? ~startN : startN; const endN = binarySearch2(da.length, i => Number(da.row(i).address - lastAddr)); <del> const end = endN < 0 ? ~endN : endN; </del> <ins> const end = endN < 0 ? ~endN : endN + 1; </ins> const toDelete = end - start; // Go through everything we're about to add, and only show the source


let textModel: ITextModel | undefined = undefined; const sourceSB = new StringBuilder(10000); const ref = await this.textModelService.createModelReference(sourceURI); <ins> if (templateData.currentElement.element !== element) { return; // avoid a race, #192831 } </ins> textModel = ref.object.textEditorModel; templateData.cellDisposable.push(ref);


rename(title?: string): Promise<void>; /** <del> * Triggers a quick pick to change the icon of this terminal. </del> <ins> * Sets or triggers a quick pick to change the icon of this terminal. </ins> */ <del> changeIcon(): Promise<void>; </del> <ins> changeIcon(icon?: TerminalIcon): Promise<TerminalIcon | undefined>; </ins> /** <del> * Triggers a quick pick to change the color of the associated terminal tab icon. </del> <ins> * Sets or triggers a quick pick to change the color of the associated terminal tab icon. </ins> */ <del> changeColor(): Promise<void>; </del> <ins> changeColor(color?: string): Promise<string | undefined>; </ins> /** * Triggers a quick pick that displays recent commands or cwds. Selecting one will


import { INotificationService, Severity } from 'vs/platform/notification/common/notification'; import { IOpenerService } from 'vs/platform/opener/common/opener'; import { IPickOptions, IQuickInputService, IQuickPickItem } from 'vs/platform/quickinput/common/quickInput'; <del> import { ITerminalProfile, TerminalExitReason, TerminalLocation, TerminalSettingId } from 'vs/platform/terminal/common/terminal'; </del> <ins> import { ITerminalProfile, TerminalExitReason, TerminalIcon, TerminalLocation, TerminalSettingId } from 'vs/platform/terminal/common/terminal'; </ins> import { IWorkspaceContextService, IWorkspaceFolder } from 'vs/platform/workspace/common/workspace'; import { PICK_WORKSPACE_FOLDER_COMMAND_ID } from 'vs/workbench/browser/actions/workspaceCommands'; import { CLOSE_EDITOR_COMMAND_ID } from 'vs/workbench/browser/parts/editor/editorCommands';


title: terminalStrings.changeIcon, f1: false, precondition: ContextKeyExpr.and(ContextKeyExpr.or(TerminalContextKeys.processSupported, TerminalContextKeys.terminalHasBeenCreated), TerminalContextKeys.tabsSingularSelection), <del> run: (c, accessor) => getSelectedInstances(accessor)?.[0].changeIcon() </del> <ins> run: async (c, accessor) => { let icon: TerminalIcon | undefined; for (const terminal of getSelectedInstances(accessor) ?? []) { icon = await terminal.changeIcon(icon); } } </ins> }); registerTerminalAction({


title: terminalStrings.changeColor, f1: false, precondition: ContextKeyExpr.and(ContextKeyExpr.or(TerminalContextKeys.processSupported, TerminalContextKeys.terminalHasBeenCreated), TerminalContextKeys.tabsSingularSelection), <del> run: (c, accessor) => getSelectedInstances(accessor)?.[0].changeColor() </del> <ins> run: async (c, accessor) => { let color: string | undefined; for (const terminal of getSelectedInstances(accessor) ?? []) { color = await terminal.changeColor(color); } } </ins> }); registerTerminalAction({


run: (c, accessor) => accessor.get(ICommandService).executeCommand(CLOSE_EDITOR_COMMAND_ID) }); <del> registerContextualInstanceAction({ </del> <ins> registerTerminalAction({ </ins> id: TerminalCommandId.KillActiveTab, title: terminalStrings.kill, f1: false,


weight: KeybindingWeight.WorkbenchContrib, when: TerminalContextKeys.tabsFocus }, <del> run: (instance, c) => c.service.safeDisposeTerminal(instance), runAfter: (instances, c) => c.groupService.focusTabs() </del> <ins> run: async (c, accessor) => { for (const terminal of getSelectedInstances(accessor) ?? []) { c.service.safeDisposeTerminal(terminal); } c.groupService.focusTabs(); } </ins> }); registerTerminalAction({


} } <del> async changeIcon() { </del> <ins> async changeIcon(icon?: TerminalIcon): Promise<TerminalIcon | undefined> { if (icon) { this._icon = icon; this._onIconChanged.fire({ instance: this, userInitiated: true }); return icon; } </ins> type Item = IQuickPickItem & { icon: TerminalIcon }; const items: Item[] = []; for (const icon of getAllCodicons()) {


if (result) { this._icon = result.icon; this._onIconChanged.fire({ instance: this, userInitiated: true }); <ins> return this._icon; </ins> } <ins> return; </ins> } <del> async changeColor() { </del> <ins> async changeColor(color?: string): Promise<string | undefined> { if (color) { this.shellLaunchConfig.color = color; this._onIconChanged.fire({ instance: this, userInitiated: true }); return color; } </ins> const icon = this._getIcon(); if (!icon) { return;


quickPick.hide(); colorStyleDisposable.dispose(); <ins> return result?.id; </ins> } selectPreviousSuggestion(): void {


const keys = ['audioCues.diffLineDeleted', 'audioCues.diffLineInserted', 'audioCues.diffLineModified']; const content = [ localize('msg1', "You are in a diff editor."), <del> localize('msg2', "View the next {0} or previous {1} diff in diff review mode that is optimized for screen readers.", next, previous), </del> <ins> localize('msg2', "View the next ({0}) or previous ({1}) diff in diff review mode that is optimized for screen readers.", next, previous), </ins> localize('msg3', "To control which audio cues should be played, the following settings can be configured: {0}.", keys.join(', ')), ]; const commentCommandInfo = getCommentCommandInfo(keybindingService, contextKeyService, codeEditor);


import { killTerminalIcon, newTerminalIcon } from 'vs/workbench/contrib/terminal/browser/terminalIcons'; import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService'; import { Iterable } from 'vs/base/common/iterator'; <del> import { AccessibleViewProviderId, accessibleViewCurrentProviderId, accessibleViewOnLastLine } from 'vs/workbench/contrib/accessibility/browser/accessibilityConfiguration'; </del> <ins> import { AccessibleViewProviderId, accessibleViewCurrentProviderId, accessibleViewIsShown, accessibleViewOnLastLine } from 'vs/workbench/contrib/accessibility/browser/accessibilityConfiguration'; </ins> export const switchTerminalActionViewItemSeparator = 'u2500u2500u2500u2500u2500u2500u2500u2500u2500'; export const switchTerminalShowTabsTitle = localize('showTerminalTabs', "Show Tabs");


keybinding: [ { primary: KeyMod.CtrlCmd | KeyCode.KeyR, <del> when: ContextKeyExpr.and(TerminalContextKeys.focus, CONTEXT_ACCESSIBILITY_MODE_ENABLED), </del> <ins> when: ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, ContextKeyExpr.or(TerminalContextKeys.focus, ContextKeyExpr.and(accessibleViewIsShown, accessibleViewCurrentProviderId.isEqualTo(AccessibleViewProviderId.Terminal)))), </ins> weight: KeybindingWeight.WorkbenchContrib }, {


if (this._hasShellIntegration) { const shellIntegrationCommandList = []; shellIntegrationCommandList.push(localize('shellIntegration', "The terminal has a feature called shell integration that offers an enhanced experience and provides useful commands for screen readers such as:")); <del> shellIntegrationCommandList.push('- ' + this._descriptionForCommand(TerminalCommandId.AccessibleBufferGoToNextCommand, localize('goToNextCommand', 'Go to Next Command ({0})'), localize('goToNextCommandNoKb', 'Go to Next Command is currently not triggerable by a keybinding.'))); shellIntegrationCommandList.push('- ' + this._descriptionForCommand(TerminalCommandId.AccessibleBufferGoToPreviousCommand, localize('goToPreviousCommand', 'Go to Previous Command ({0})'), localize('goToPreviousCommandNoKb', 'Go to Previous Command is currently not triggerable by a keybinding.'))); </del> <ins> shellIntegrationCommandList.push('- ' + this._descriptionForCommand(TerminalCommandId.AccessibleBufferGoToNextCommand, localize('goToNextCommand', 'Go to Next Command ({0}) in the accessible view'), localize('goToNextCommandNoKb', 'Go to Next Command in the accessible view is currently not triggerable by a keybinding.'))); shellIntegrationCommandList.push('- ' + this._descriptionForCommand(TerminalCommandId.AccessibleBufferGoToPreviousCommand, localize('goToPreviousCommand', 'Go to Previous Command ({0}) in the accessible view'), localize('goToPreviousCommandNoKb', 'Go to Previous Command in the accessible view is currently not triggerable by a keybinding.'))); </ins> shellIntegrationCommandList.push('- ' + this._descriptionForCommand(AccessibilityCommandId.GoToSymbol, localize('goToSymbol', 'Go to Symbol ({0})'), localize('goToSymbolNoKb', 'Go to symbol is currently not triggerable by a keybinding.'))); shellIntegrationCommandList.push('- ' + this._descriptionForCommand(TerminalCommandId.RunRecentCommand, localize('runRecentCommand', 'Run Recent Command ({0})'), localize('runRecentCommandNoKb', 'Run Recent Command is currently not triggerable by a keybinding.'))); shellIntegrationCommandList.push('- ' + this._descriptionForCommand(TerminalCommandId.GoToRecentDirectory, localize('goToRecentDirectory', 'Go to Recent Directory ({0})'), localize('goToRecentDirectoryNoKb', 'Go to Recent Directory is currently not triggerable by a keybinding.')));


async getBranchBase(ref: string): Promise<Branch | undefined> { const branch = await this.getBranch(ref); <del> const branchMergeBaseConfigKey = `branch.${branch.name}.vscode-merge-base`; </del> <ins> const branchUpstream = await this.getUpstreamBranch(branch); </ins> <del> // Upstream if (branch.upstream) { return await this.getBranch(`refs/remotes/${branch.upstream.remote}/${branch.upstream.name}`); </del> <ins> if (branchUpstream) { return branchUpstream; </ins> } // Git config <ins> const mergeBaseConfigKey = `branch.${branch.name}.vscode-merge-base`; </ins> try { <del> const mergeBase = await this.getConfig(branchMergeBaseConfigKey); if (mergeBase !== '') { const mergeBaseBranch = await this.getBranch(mergeBase); return mergeBaseBranch; </del> <ins> const mergeBase = await this.getConfig(mergeBaseConfigKey); const branchFromConfig = mergeBase !== '' ? await this.getBranch(mergeBase) : undefined; if (branchFromConfig) { return branchFromConfig; </ins> } } catch (err) { } // Reflog const branchFromReflog = await this.getBranchBaseFromReflog(ref); <del> if (branchFromReflog) { await this.setConfig(branchMergeBaseConfigKey, branchFromReflog.name!); return branchFromReflog; </del> <ins> const branchFromReflogUpstream = branchFromReflog ? await this.getUpstreamBranch(branchFromReflog) : undefined; if (branchFromReflogUpstream) { await this.setConfig(mergeBaseConfigKey, `${branchFromReflogUpstream.remote}/${branchFromReflogUpstream.name}`); return branchFromReflogUpstream; </ins> } // Default branch const defaultBranch = await this.getDefaultBranch(); if (defaultBranch) { <del> await this.setConfig(branchMergeBaseConfigKey, defaultBranch.name!); </del> <ins> await this.setConfig(mergeBaseConfigKey, `${defaultBranch.remote}/${defaultBranch.name}`); </ins> return defaultBranch; }