MenuRegistry.appendMenuItem(MenuId.EditorActionsPositionSubmenu, { command: { id: EditorActionsTitleBarAction.ID, title: localize('titleBar', "Title Bar"), toggled: ContextKeyExpr.or(ContextKeyExpr.equals('config.workbench.editor.editorActionsLocation', 'titleBar'), ContextKeyExpr.and(ContextKeyExpr.equals('config.workbench.editor.showTabs', 'none'), ContextKeyExpr.equals('config.workbench.editor.editorActionsLocation', 'default'))) }, group: '1_config', order: 20 }); MenuRegistry.appendMenuItem(MenuId.EditorActionsPositionSubmenu, { command: { id: HideEditorActionsAction.ID, title: localize('hidden', "Hidden"), toggled: ContextKeyExpr.equals('config.workbench.editor.editorActionsLocation', 'hidden') }, group: '1_config', order: 30 }); <ins> MenuRegistry.appendMenuItem(MenuId.EditorTabsBarContext, { command: { id: ConfigureEditorTabsAction.ID, title: localize('configureTabs', "Configure Tabs ...") }, group: '9_configure', order: 10 }); </ins> // Editor Title Context Menu MenuRegistry.appendMenuItem(MenuId.EditorTitleContext, { command: { id: CLOSE_EDITOR_COMMAND_ID, title: localize('close', "Close") }, group: '1_close', order: 10 }); MenuRegistry.appendMenuItem(MenuId.EditorTitleContext, { command: { id: CLOSE_OTHER_EDITORS_IN_GROUP_COMMAND_ID, title: localize('closeOthers', "Close Others"), precondition: EditorGroupEditorsCountContext.notEqualsTo('1') }, group: '1_close', order: 20 });


this.domNode = undefined; })); <ins> this.toDispose.add(dom.addDisposableListener(this.domNode, dom.EventType.CONTEXT_MENU, (e) => { this.contextMenuService.showContextMenu({ getAnchor: () => { return new StandardMouseEvent(dom.getActiveWindow(), e); }, getActions: () => { return [{ id: 'workench.action.disableTerminalInitialHint', label: localize('disableInitialHint', "Disable Initial Hint"), tooltip: localize('disableInitialHint', "Disable Initial Hint"), enabled: true, class: undefined, run: () => this.configurationService.updateValue(TerminalInitialHintSettingId.Enabled, false) } ]; } }); })); </ins> } return this.domNode; }


"@vscode/l10n": "^0.0.11", "jsonc-parser": "^3.2.0", "request-light": "^0.7.0", <del> "vscode-json-languageservice": "^5.3.1", </del> <ins> "vscode-json-languageservice": "^5.3.2", </ins> "vscode-languageserver": "^8.1.0", "vscode-uri": "^3.0.7" },


} switch (e.data.type) { <del> case 'setScale': </del> <ins> case 'setScale': { </ins> updateScale(e.data.scale); break; <del> case 'setActive': </del> <ins> } case 'setActive': { </ins> setActive(e.data.value); break; <del> case 'zoomIn': </del> <ins> } case 'zoomIn': { </ins> zoomIn(); break; <del> case 'zoomOut': </del> <ins> } case 'zoomOut': { </ins> zoomOut(); break; <ins> } case 'copyImage': { copyImage(); break; } </ins> } }); <ins> document.addEventListener('copy', () => { copyImage(); }); async function copyImage() { try { await navigator.clipboard.write([new ClipboardItem({ 'image/png': fetch(image.src).then(request => request.blob()) })]); } catch (e) { console.error(e); } } </ins> }());


} } <del> private count(): number { return this.panes.reduce((count, view) => (<ExtensionsListView>view).count() + count, 0); </del> <ins> private getFirstExpandedPane(): ExtensionsListView | undefined { for (const pane of this.panes) { if (pane.isExpanded() && pane instanceof ExtensionsListView) { return pane; } } return undefined; </ins> } private focusListView(): void { <del> if (this.count() > 0) { this.panes[0].focus(); </del> <ins> const pane = this.getFirstExpandedPane(); if (pane && pane.count() > 0) { pane.focus(); </ins> } }


}); } <ins> function consoleLogFn(msg) { const type = msg.type(); const candidate = console[type]; if (candidate) { return candidate; } if (type === 'warning') { return console.warn; } return console.log; } </ins> function pkill(pid: number): Promise<void> { return new Promise((c, e) => { kill(pid, error => error ? e(error) : c());


} const scopedContextKeyService = this._register(_contextKeyService.createScoped(this._wrapperElement)); <ins> this._scopedContextKeyService = scopedContextKeyService; </ins> this._scopedInstantiationService = instantiationService.createChild(new ServiceCollection( [IContextKeyService, scopedContextKeyService] ));


{ "open": "{", "close": "}" }, { "open": "(", "close": ")" }, { "open": "'", "close": "'", "notIn": ["string", "comment"] }, <del> { "open": """, "close": """, "notIn": ["string"] } </del> <ins> { "open": """, "close": """, "notIn": ["string"] }, { "open": "/*", "close": " */", "notIn": ["string", "comment"] } </ins> ], "surroundingPairs": [ ["{", "}"],


import { Codicon } from 'vs/base/common/codicons'; import { registerIcon } from 'vs/platform/theme/common/iconRegistry'; import { UntitledTextEditorInputSerializer, UntitledTextEditorWorkingCopyEditorHandler } from 'vs/workbench/services/untitled/common/untitledTextEditorHandler'; <del> import { DynamicEditorGroupAutoLockConfiguration } from 'vs/workbench/browser/parts/editor/editorConfiguration'; </del> <ins> import { DefaultBinaryEditorConfiguration, DynamicEditorGroupAutoLockConfiguration } from 'vs/workbench/browser/parts/editor/editorConfiguration'; </ins> //#region Editor Registrations


export const InteractiveWindowSetting = { interactiveWindowAlwaysScrollOnNewCell: 'interactiveWindow.alwaysScrollOnNewCell', <del> interactiveWindowHotExit: 'interactiveWindow.hotExit' </del> <ins> interactiveWindowRestore: 'interactiveWindow.restore' </ins> };


model.dispose(); mode.dispose(); }); <ins> test('issue #45369: Select to Bracket with multicursor', () => { let mode = new BracketMode(); let model = TextModel.createFromString('{  }   {   }   { }', undefined, mode.getLanguageIdentifier()); withTestCodeEditor(null, { model: model }, (editor, cursor) => { let bracketMatchingController = editor.registerAndInstantiateContribution<BracketMatchingController>(BracketMatchingController); // cursors inside brackets become selections of the entire bracket contents editor.setSelections([ new Selection(1, 3, 1, 3), new Selection(1, 10, 1, 10), new Selection(1, 17, 1, 17) ]); bracketMatchingController.selectToBracket(); assert.deepEqual(editor.getSelections(), [ new Selection(1, 1, 1, 5), new Selection(1, 8, 1, 13), new Selection(1, 16, 1, 19) ]); // cursors to the left of bracket pairs become selections of the entire pair editor.setSelections([ new Selection(1, 1, 1, 1), new Selection(1, 6, 1, 6), new Selection(1, 14, 1, 14) ]); bracketMatchingController.selectToBracket(); assert.deepEqual(editor.getSelections(), [ new Selection(1, 1, 1, 5), new Selection(1, 8, 1, 13), new Selection(1, 16, 1, 19) ]); // cursors just right of a bracket pair become selections of the entire pair editor.setSelections([ new Selection(1, 5, 1, 5), new Selection(1, 13, 1, 13), new Selection(1, 19, 1, 19) ]); bracketMatchingController.selectToBracket(); assert.deepEqual(editor.getSelections(), [ new Selection(1, 1, 1, 5), new Selection(1, 8, 1, 13), new Selection(1, 16, 1, 19) ]); bracketMatchingController.dispose(); }); model.dispose(); mode.dispose(); }); </ins> });


} get persistentProcessId(): number | undefined { return this._processManager.persistentProcessId; } <del> get shouldPersist(): boolean { return this._processManager.shouldPersist; } </del> <ins> get shouldPersist(): boolean { return this._processManager.shouldPersist && !this.shellLaunchConfig.disablePersistence; } </ins> /** * Create xterm.js instance and attach data listeners.


} private onReady(container: HTMLElement, recentlyOpened: TPromise<{ files: URI[]; workspaces: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier)[]; }>, installedExtensions: TPromise<IExtensionStatus[]>): void { <del> const enabled = isWelcomePageEnabled(this.configurationService); </del> <ins> const enabled = isWelcomePageEnabled(this.configurationService, this.contextService); </ins> const showOnStartup = <HTMLInputElement>container.querySelector('#showOnStartup'); if (enabled) { showOnStartup.setAttribute('checked', 'checked');


MenuRegistry.appendMenuItem(MenuId.EditorTitle, { command: { id: TOGGLE_MAXIMIZE_EDITOR_GROUP, title: localize('maximizeGroup', "Maximize Group") }, group: '8_group_operations', order: 5, when: ContextKeyExpr.and(EditorPartMaximizedEditorGroupContext.negate(), EditorPartMultipleEditorGroupsContext) }); MenuRegistry.appendMenuItem(MenuId.EditorTitle, { command: { id: TOGGLE_MAXIMIZE_EDITOR_GROUP, title: localize('unmaximizeGroup', "Unmaximize Group") }, group: '8_group_operations', order: 5, when: EditorPartMaximizedEditorGroupContext }); MenuRegistry.appendMenuItem(MenuId.EditorTitle, { command: { id: TOGGLE_LOCK_GROUP_COMMAND_ID, title: localize('lockGroup', "Lock Group"), toggled: ActiveEditorGroupLockedContext }, group: '8_group_operations', order: 10, when: IsAuxiliaryEditorPartContext.toNegated() /* already a primary action for aux windows */ }); <ins> MenuRegistry.appendMenuItem(MenuId.EditorTitle, { command: { id: ConfigureEditorAction.ID, title: localize('configureEditor', "Configure Editor ...") }, group: '9_configure', order: 10 }); </ins> function appendEditorToolItem(primary: ICommandAction, when: ContextKeyExpression | undefined, order: number, alternative?: ICommandAction, precondition?: ContextKeyExpression | undefined): void { const item: IMenuItem = {


{ "name": "code-oss-dev", "version": "1.83.0", <del> "distro": "46e7bb69af9f06de037c3d7e8f61de4a679f9ef1", </del> <ins> "distro": "c13fa037c20b672a48c9e7990df10998974196f9", </ins> "author": { "name": "Microsoft Corporation" },


* Given a stable rendered state, checks every rendered element whether it needs * to be probed for dynamic height. Adjusts scroll height and top if necessary. */ <del> private _rerender(renderTop: number, renderHeight: number): void { </del> <ins> private _rerender(renderTop: number, renderHeight: number, updateScrollTop: boolean = true): void { </ins> const previousRenderRange = this.getRenderRange(renderTop, renderHeight); // Let's remember the second element's position, this helps in scrolling up


} if (shadowElement) { <del> this.updateShadowElement(shadowElement, dimension, position); </del> <ins> this.updateShadowElement(shadowElement, dimension, /*position*/ undefined); </ins> } if (this._shadowElementViewInfo && this._shadowElementViewInfo.width <= 0 && this._shadowElementViewInfo.height <= 0) {


const userExtensions = await this.webExtensionsScannerService.scanUserExtensions(profileLocation ?? this.userDataProfileService.currentProfile.extensionsResource); extensions.push(...userExtensions); } <del> return Promise.all(extensions.map(e => toLocalExtension(e))); </del> <ins> return extensions.map(e => toLocalExtension(e)); </ins> } async install(location: URI, options: InstallOptions = {}): Promise<ILocalExtension> {


} getScopedEnvironmentVariableCollection(scope: vscode.EnvironmentVariableScope | undefined): IEnvironmentVariableCollection { <del> if (this._extension && scope) { // TODO: This should be removed when the env var extension API(s) are stabilized checkProposedApiEnabled(this._extension, 'envCollectionWorkspace'); } </del> const scopedCollectionKey = this.getScopeKey(scope); let scopedCollection = this.scopedCollections.get(scopedCollectionKey); if (!scopedCollection) {


}); } <ins> private onDidChangeActivityBarLocation(): void { this.updateTitleArea(); const id = this.getActiveComposite()?.getId(); if (id) { this.onTitleAreaUpdate(id!); } this.updateActivityBarVisiblity(); this.rememberActivityBarVisiblePosition(); } </ins> override updateStyles(): void { super.updateStyles();


// folder.1=>folder.2 if (isFolder && name.match(/(d+)$/)) { <del> return name.replace(/(d+)$/, (match: string, ...groups: any[]) => { return strings.pad(parseInt(groups[0]) + 1, groups[0].length); }); </del> <ins> return name.replace(/(d+)$/, (match: string, ...groups: any[]) => { let number = parseInt(groups[0]); return number < maxNumber ? strings.pad(number + 1, groups[0].length) : strings.format('{0}.1', groups[0]); }); </ins> } // 1.folder=>2.folder if (isFolder && name.match(/^(d+)/)) { <del> return name.replace(/^(d+)/, (match: string, ...groups: any[]) => { return strings.pad(parseInt(groups[0]) + 1, groups[0].length); }); </del> <ins> return name.replace(/^(d+)(.*)$/, (match: string, ...groups: any[]) => { let number = parseInt(groups[0]); return number < maxNumber ? strings.pad(number + 1, groups[0].length) + groups[1] : strings.format('{0}{1}.1', groups[0], groups[1]); }); </ins> } // file/folder=>file.1/folder.1


// Each line and column clause have 6 groups (ie no. of expressions in round brackets) export const lineAndColumnClauseGroupCount = 6; <del> const MAX_LENGTH = 2000; </del> <ins> const InvalidLinkResult = 'Invalid Link Result'; const MAX_LENGTH = 2000; let map = new Map<string, TerminalLink | string>(); </ins> export class TerminalValidatedLocalLinkProvider extends TerminalBaseLinkProvider { constructor( private readonly _xterm: Terminal,


}) ); } <del> export const foldBackgroundBackground = registerColor('editor.foldBackground', { light: transparent(editorSelectionBackground, 0.3), dark: transparent(editorSelectionBackground, 0.3), hcDark: null, hcLight: null }, nls.localize('foldBackgroundBackground', "Background color behind folded ranges. The color must not be opaque so as not to hide underlying decorations."), true); export const editorFoldForeground = registerColor('editorGutter.foldingControlForeground', { dark: iconForeground, light: iconForeground, hcDark: iconForeground, hcLight: iconForeground }, nls.localize('editorGutter.foldingControlForeground', 'Color of the folding control in the editor gutter.')); </del>


import { TerminalStatus } from 'vs/workbench/contrib/terminal/browser/terminalStatusList'; import Severity from 'vs/base/common/severity'; import { ICommandService } from 'vs/platform/commands/common/commands'; <ins> import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions'; </ins> export class EnvironmentVariableInfoStale implements IEnvironmentVariableInfo { readonly requiresAction = true;


} } <ins> export class LineSequence implements ISequence { constructor( private readonly trimmedHash: number[], private readonly lines: string[] ) { } getElement(offset: number): number { return this.trimmedHash[offset]; } get length(): number { return this.trimmedHash.length; } getBoundaryScore(length: number): number { const indentationBefore = length === 0 ? 0 : getIndentation(this.lines[length - 1]); const indentationAfter = length === this.lines.length ? 0 : getIndentation(this.lines[length]); return 1000 - (indentationBefore + indentationAfter); } } function getIndentation(str: string): number { let i = 0; while (i < str.length && (str.charCodeAt(i) === CharCode.Space || str.charCodeAt(i) === CharCode.Tab)) { i++; } return i; } </ins> class Slice implements ISequence { private readonly elements: Int32Array; private readonly firstCharOnLineOffsets: Int32Array;


declare function require(path: string): any; <del> const enabledSetting = 'markdown.math.enabled'; </del> <ins> const markdownMathSetting = 'markdown.math'; </ins> export function activate(context: vscode.ExtensionContext) { function isEnabled(): boolean {


displayName: Extract openssl prebuilt # inspired by: https://github.com/emk/rust-musl-builder/blob/main/Dockerfile <del> - bash: | set -e sudo apt-get update sudo apt-get install -yq build-essential curl file git graphviz musl-dev musl-tools linux-libc-dev pkgconf zip unzip xutils-dev ninja-build sudo ln -s "/usr/bin/g++" "/usr/bin/musl-g++" || echo "link exists" displayName: Install build dependencies </del> <ins> - ${{ if or(eq(parameters.VSCODE_BUILD_LINUX_ALPINE_ARM64, true), eq(parameters.VSCODE_BUILD_LINUX_ALPINE, true)) }}: - bash: | set -e sudo apt-get update sudo apt-get install -yq build-essential musl-dev musl-tools linux-libc-dev pkgconf xutils-dev sudo ln -s "/usr/bin/g++" "/usr/bin/musl-g++" || echo "link exists" displayName: Install musl build dependencies </ins> - ${{ if eq(parameters.VSCODE_BUILD_LINUX_ARMHF, true) }}: - bash: | set -e sudo apt-get install -yq gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf binutils-arm-linux-gnueabihf <del> displayName: Install cross compilation toolchains </del> <ins> displayName: Install arm32 toolchains - ${{ if eq(parameters.VSCODE_BUILD_LINUX_ARM64, true) }}: - bash: | set -e sudo apt-get install -yq gcc-aarch64-linux-gnu g++-aarch64-linux-gnu binutils-aarch64-linux-gnu displayName: Install arm64 toolchains </ins> - task: NodeTool@0 inputs:


// do not scroll the viewport if resized element is out of viewport heightDiff = size - originalSize; } else { <del> if (anchorIndex !== null && anchorIndex > index && anchorIndex <= lastRenderRange.end) { </del> <ins> if (anchorIndex !== null && anchorIndex > index && anchorIndex < lastRenderRange.end) { </ins> // anchor in viewport // resized element in viewport and above the anchor heightDiff = size - originalSize;


const computedSliderRatio = (maxMinimapSliderTop) / (scrollHeight - viewportHeight); const sliderTop = (scrollTop * computedSliderRatio); <del> if (minimapLinesFitting >= lineCount) { </del> <ins> let extraLinesAtTheBottom = 0; if (options.scrollBeyondLastLine) { const expectedViewportLineCount = viewportHeight / lineHeight; extraLinesAtTheBottom = expectedViewportLineCount; } if (minimapLinesFitting >= lineCount + extraLinesAtTheBottom) { </ins> // All lines fit in the minimap const startLineNumber = 1; const endLineNumber = lineCount;


let goToSymbolHint = ''; if (providerHasSymbols) { if (goToSymbolKb) { <del> goToSymbolHint = localize('goToSymbolHint', 'Go to a symbol ({0})', goToSymbolKb); </del> <ins> goToSymbolHint = localize('goToSymbolHint', 'Go to a symbol ({0}).', goToSymbolKb); </ins> } else { goToSymbolHint = localize('goToSymbolHintNoKb', 'To go to a symbol, configure a keybinding for the command Go To Symbol in Accessible View'); }


<del> <svg xmlns="http://www.w3.org/2000/svg" width="12" height="18" viewBox="0 0 12 18"><style>.st0{fill:#fff}</style><title>flipped-cursor-mac</title><path d="M4.3 16.5l1.6-4.6H1.1L11.5 1.2v14.4L8.7 13l-1.6 4.5z"/><path class="st0" d="M11 14.5l-2.5-2.3L7 16.7 5 16l1.6-4.5h-4l8.5-9M0 12.5h5.2l-1.5 4.1L7.5 18 9 14.2l2.9 2.3V0L0 12.5z"/></svg> </del>  No newline at end of file <ins> <svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 13 19" style="enable-background:new 0 0 13 19;" width="13" height="19"><style type="text/css">.st0{stroke:#FFFFFF;stroke-miterlimit:10;}</style><title>flipped-cursor-mac</title><path class="st0" d="M5.3,16.6l1.6-4.7H2.1L12.5,1.2v14.4L9.7,13l-1.6,4.6c-0.2,0.5-0.8,0.8-1.3,0.6L6,17.9 C5.4,17.7,5.1,17.2,5.3,16.6z"/></svg> </ins>


*--------------------------------------------------------------------------------------------*/ import * as assert from 'assert'; <del> import { IWorkingCopy, IWorkingCopyBackup } from 'vs/workbench/services/workingCopy/common/workingCopyService'; </del> <ins> import { IWorkingCopy, IWorkingCopyBackup, WorkingCopyCapabilities } from 'vs/workbench/services/workingCopy/common/workingCopyService'; </ins> import { URI } from 'vs/base/common/uri'; import { Emitter } from 'vs/base/common/event'; import { Disposable } from 'vs/base/common/lifecycle';


) { super(); <ins> this._widget = this._register(this._instantiationService.createInstance(ResizableHoverWidget, this._editor)); </ins> // Instantiate participants and sort them by `hoverOrdinal` which is relevant for rendering order. this._participants = []; for (const participant of HoverParticipantRegistry.getAll()) {


font-weight: normal; } <ins> h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { font-size: inherit; line-height: auto; } </ins> a:hover { color: #4080D0; text-decoration: underline;


const err = new Error('An extension called process.crash() and this was prevented.'); console.warn(err.stack); }; <ins> // Set ELECTRON_RUN_AS_NODE environment variable for extensions that use // child_process.spawn with process.execPath and expect to run as node process // on the desktop. // Refs https://github.com/microsoft/vscode/issues/151012#issuecomment-1156593228 process.env['ELECTRON_RUN_AS_NODE'] = '1'; </ins> } interface IRendererConnection {


*--------------------------------------------------------------------------------------------*/ import { Event } from 'vs/base/common/event'; <del> import { IWorkbenchContribution } from 'vs/workbench/common/contributions'; import { IDebugService, VIEWLET_ID, IDebugSession } from 'vs/workbench/contrib/debug/common/debug'; </del> <ins> import { IDisposable, dispose } from 'vs/base/common/lifecycle'; </ins> import { IProgressService, ProgressLocation } from 'vs/platform/progress/common/progress'; <del> import { dispose, IDisposable } from 'vs/base/common/lifecycle'; </del> <ins> import { IWorkbenchContribution } from 'vs/workbench/common/contributions'; import { IDebugService, IDebugSession, VIEWLET_ID } from 'vs/workbench/contrib/debug/common/debug'; </ins> import { IViewsService } from 'vs/workbench/services/views/common/viewsService'; <del> import { NotificationPriority } from 'vs/platform/notification/common/notification'; </del> export class DebugProgressContribution implements IWorkbenchContribution {


} private _updateContentsDomNodeMaxDimensions() { <del> const width = Math.max(this._editor.getLayoutInfo().width * 0.66, 500); const height = Math.max(this._editor.getLayoutInfo().height / 4, 250); </del> <ins> const height = Math.max(this._editor.getLayoutInfo().height / 4, 250, ContentHoverWidget._lastDimensions.height); const width = Math.max(this._editor.getLayoutInfo().width * 0.66, 500, ContentHoverWidget._lastDimensions.width); </ins> this._setContentsDomNodeMaxDimensions(width, height); }


return ''; } <ins> private get selectedText(): string { const activeEditor = this.editorService.getActiveEditor(); if (activeEditor) { const editorControl = (<ICodeEditor>activeEditor.getControl()); if (editorControl) { const editorModel = editorControl.getModel(); const editorSelection = editorControl.getSelection(); if (editorModel && editorSelection) { return editorModel.getValueInRange(editorSelection); } } } return ''; } </ins> private getFilePath(): string { let input = this.editorService.getActiveEditorInput(); if (input instanceof DiffEditorInput) {


this.container.style.marginLeft = `${marginWithoutIndentation}px`; } <del> setWidgetMargins(position: Position, indentationWidth?: number): void { if (indentationWidth === undefined) { indentationWidth = this._calculateIndentationWidth(position); } </del> <ins> setWidgetMargins(position: Position): void { const indentationWidth = this._calculateIndentationWidth(position); </ins> if (this._indentationWidth === indentationWidth) { return; }


this._domNode.domNode.height = height * ratio; const ctx = this._domNode.domNode.getContext('2d')!; ctx.clearRect(0, 0, this.width * ratio, height * ratio); <del> this._renderCanvas(ctx, this.width * ratio, height * ratio, scrollHeight * ratio, ratio); </del> <ins> this._renderCanvas(ctx, this.width * ratio, height * ratio, contentHeight * ratio, ratio); </ins> this._renderOverviewViewport(); }


private openAsBinary(input: FileEditorInput, options: ITextEditorOptions | undefined): void { <del> // Mark file input for forced binary opening input.setForceOpenAsBinary(); // Open in group (this.group ?? this.editorGroupService.activeGroup).openEditor(input, { </del> <ins> const defaultBinaryEditor = this.configurationService.getValue<string | undefined>('workbench.editor.defaultBinaryEditor'); const groupToOpen = this.group ?? this.editorGroupService.activeGroup; const editorOptions = { </ins> ...options, // Make sure to not steal away the currently active group // because we are triggering another openEditor() call // and do not control the initial intent that resulted // in us now opening as binary. activation: EditorActivation.PRESERVE <del> }); </del> <ins> }; // If we the user setting specifies a default binary editor we use that. if (defaultBinaryEditor && defaultBinaryEditor !== '') { this.editorService.replaceEditors([{ editor: input, replacement: { resource: input.resource, options: { ...editorOptions, override: defaultBinaryEditor } } }], groupToOpen); } else { // Mark file input for forced binary opening input.setForceOpenAsBinary(); // Open in group groupToOpen.openEditor(input, editorOptions); } </ins> } private async openAsFolder(input: FileEditorInput): Promise<void> {


} private get centeredEditorAvailableSize(): number { <del> return this.silosSize[Position.ONE] - EditorGroupsControl.CENTERED_EDITOR_MIN_MARGIN * 2; </del> <ins> return this.dimension.width - EditorGroupsControl.CENTERED_EDITOR_MIN_MARGIN * 2; </ins> } private get centeredEditorSize(): number { <del> return Math.min(this.centeredEditorAvailableSize, this.centeredEditorPreferedSize); </del> <ins> return Math.min(this.centeredEditorAvailableSize, this.centeredEditorPreferredSize); </ins> } private get centeredEditorPosition(): number {


// Default Filter return enableSeparateSubstringMatching ? fuzzySeparateFilter(word, wordToMatchAgainst) : fuzzyContiguousFilter(word, wordToMatchAgainst); } <ins> export function matchesFuzzy2(pattern: string, word: string): IMatch[] | undefined { pattern = pattern.toLowerCase(); word = word.toLowerCase(); let result: IMatch[] = []; let lastMatch: IMatch; let patternPos = 0; let wordPos = 0; while (patternPos < pattern.length && wordPos < word.length) { if (pattern.charAt(patternPos) === word.charAt(wordPos)) { patternPos += 1; if (lastMatch && lastMatch.end === wordPos) { lastMatch.end += 1; } else { lastMatch = { start: wordPos, end: wordPos + 1 }; result.push(lastMatch); } } wordPos += 1; } if (patternPos !== pattern.length) { return undefined; } return result; } export function matchesFuzzy3(pattern: string, word: string) { return _doMatchesFuzzy3( pattern, pattern.toLowerCase(), 0, word, word.toLowerCase(), 0, [], 0 ); } function _doMatchesFuzzy3( pattern: string, lowPattern: string, patternPos: number, word: string, lowWord: string, wordPos: number, positions: number[], score: number ): [IMatch[], number] { let retryPoints: number[] = []; let lastDidMatch = false; while (patternPos < lowPattern.length && wordPos < lowWord.length) { const charLowPattern = lowPattern.charAt(patternPos); const charLowWord = lowWord.charAt(wordPos); if (charLowPattern === charLowWord) { if (positions.length === 0) { score = -Math.min(wordPos, 3) * 3; // penalty -> gaps at start } else if (lastDidMatch) { score += 1; // bonus -> subsequent match } if (charLowWord !== word.charAt(wordPos)) { score += 10; // bonus -> upper-case } else if (wordPos > 0 && word.charAt(wordPos).match(_separator)) { score += 10; // bonus -> after a separator } else { // keep this as a retry point retryPoints.push(patternPos, wordPos + 1, positions.length, score); } patternPos += 1; positions.push(wordPos); lastDidMatch = true; } else { lastDidMatch = false; score -= 1; // penalty -> gaps in match } wordPos += 1; } if (patternPos !== lowPattern.length) { return undefined; } const matches: IMatch[] = []; let lastMatch: IMatch; for (const pos of positions) { if (lastMatch && lastMatch.end === pos) { lastMatch.end += 1; } else { lastMatch = { start: pos, end: pos + 1 }; matches.push(lastMatch); } } let result: [IMatch[], number] = [matches, score]; // try alternative matches for (let i = 0; i < retryPoints.length; i += 4) { const alt = _doMatchesFuzzy3( pattern, lowPattern, retryPoints[i], word, lowWord, retryPoints[i + 1], positions.slice(0, retryPoints[i + 2]), retryPoints[i + 3] ); if (alt && alt[1] > result[1]) { result = alt; } } return result; } const _separator = /[-_. ]/; export function matchesFuzzy4(pattern: string, word: string): [IMatch[], number] { const lowPattern = pattern.toLowerCase(); const lowWord = word.toLowerCase(); const [landmarkWord, landmarkPositions] = computeLandmarks(word, lowWord); let landmarkPos = 0; let wordPos = 0; let patternPos = 1; let charLowPattern = lowPattern.charAt(0); let result: IMatch[] = []; let lastMatch: IMatch; let score = 0; if (charLowPattern === lowWord.charAt(0)) { lastMatch = { start: wordPos, end: wordPos + 1 }; result.push(lastMatch); wordPos = 1; landmarkPos = 1; if (pattern.charAt(0) === word.charAt(0)) { score += 10; } } else if ((landmarkPos = landmarkWord.indexOf(charLowPattern)) >= 0) { wordPos = landmarkPositions[landmarkPos]; score += 10 - Math.min(9, wordPos * 3); lastMatch = { start: wordPos, end: wordPos + 1 }; result.push(lastMatch); wordPos += 1; landmarkPos += 1; } else { return undefined; } while (patternPos < lowPattern.length && wordPos < lowWord.length) { charLowPattern = lowPattern.charAt(patternPos); let match = false; if (landmarkPos < landmarkWord.length && charLowPattern === landmarkWord.charAt(landmarkPos)) { let newWordPos = landmarkPositions[landmarkPos]; match = true; score += 10 - (newWordPos - wordPos); wordPos = newWordPos; landmarkPos += 1; patternPos += 1; } else if (charLowPattern === lowWord.charAt(wordPos)) { match = true; patternPos += 1; } if (match) { if (lastMatch && lastMatch.end === wordPos) { lastMatch.end += 1; score += 1; } else { lastMatch = { start: wordPos, end: wordPos + 1 }; result.push(lastMatch); } } wordPos += 1; if (wordPos >= landmarkPositions[landmarkPos]) { landmarkPos += 1; } } if (patternPos !== lowPattern.length) { return undefined; } // substract uncovered remainder score -= lowWord.length - wordPos; return [result, score]; } function computeLandmarks(word: string, lowWord: string): [string, number[]] { let result: string = ''; let positions: number[] = []; let lastCh: string; for (let pos = 0; pos < word.length; pos++) { const ch = word.charAt(pos); if (!result // first character is a landmark || (lastCh === '_' || lastCh === '-' || lastCh === ' ') // last was separator || ch !== lowWord.charAt(pos) // upper-case ) { result += ch; positions.push(pos); } lastCh = ch; } result = result.toLowerCase(); return [result, positions]; } // function print(m: number[][]) { // 	for (const n of m) { // 		console.log(n.join('|')); // 	} // } export function matchesFuzzy5(pattern: string, word: string) { // create matrix const matrix: number[][] = [[0]]; for (let i = 1; i <= pattern.length; i++) { matrix.push([-i]); } for (let i = 1; i <= word.length; i++) { matrix[0].push(-i); } for (let i = 0; i < pattern.length; i++) { let match = false; for (let j = 0; j < word.length; j++) { let diagScore = 0; if (pattern[i] === word[j]) { diagScore = 1 + matrix[i][j]; match = true; } else { diagScore = -1 + matrix[i][j]; } let upScore = -1 + matrix[i][j + 1]; let leftScore = -1 + matrix[i + 1][j]; matrix[i + 1][j + 1] = Math.max(diagScore, upScore, leftScore); } if (!match) { return undefined; } } // print(matrix); return []; } export function createMatches(position: number[]): IMatch[] { let ret: IMatch[] = []; let last: IMatch; for (const pos of position) { if (last && last.end === pos) { last.end += 1; } else { last = { start: pos, end: pos + 1 }; ret.push(last); } } return ret; } export function fuzzyMatchAndScore(pattern: string, word: string): [number, number[]] { let matches: number[] = []; let score = _matchRecursive( pattern, pattern.toLowerCase(), pattern.toUpperCase(), 0, word, word.toLowerCase(), 0, matches ); if (score <= 0) { return undefined; } score -= Math.min(matches[0], 3) * 3; // penalty for first matching character score -= (1 + matches[matches.length - 1]) - (pattern.length); // penalty for all non matching characters between first and last return [score, matches]; } export function _matchRecursive( pattern: string, lowPattern: string, upPattern: string, patternPos: number, word: string, lowWord: string, wordPos: number, matches: number[] ): number { if (patternPos >= lowPattern.length) { return 0; } const lowPatternChar = lowPattern.charAt(patternPos); let idx = -1; let value = 0; if ((patternPos === wordPos && lowPatternChar === lowWord.charAt(wordPos)) && ((value = _matchRecursive(pattern, lowPattern, upPattern, patternPos + 1, word, lowWord, wordPos + 1, matches)) >= 0) ) { matches.unshift(wordPos); return (pattern.charAt(patternPos) === word.charAt(wordPos) ? 17 : 11) + value; } if ((idx = lowWord.indexOf(`_${lowPatternChar}`, wordPos)) >= 0 && ((value = _matchRecursive(pattern, lowPattern, upPattern, patternPos + 1, word, lowWord, idx + 2, matches)) >= 0) ) { matches.unshift(idx + 1); return (pattern.charAt(patternPos) === word.charAt(idx + 1) ? 17 : 11) + value; } if ((idx = word.indexOf(upPattern.charAt(patternPos), wordPos)) >= 0 && ((value = _matchRecursive(pattern, lowPattern, upPattern, patternPos + 1, word, lowWord, idx + 1, matches)) >= 0) ) { matches.unshift(idx); return (pattern.charAt(patternPos) === word.charAt(idx) ? 17 : 11) + value; } if (patternPos > 0 && (idx = lowWord.indexOf(lowPatternChar, wordPos)) >= 0 && ((value = _matchRecursive(pattern, lowPattern, upPattern, patternPos + 1, word, lowWord, idx + 1, matches)) >= 0) ) { matches.unshift(idx); return 1 + value; } return -1; } </ins>


goMenuRegistration(); debugMenuRegistration(); tasksMenuRegistration(); <del> terminalMenuRegistration(); </del> if (isMacintosh) { windowMenuRegistration();


this._widget?.inlineChatWidget.updateInfo(''); this._widget?.inlineChatWidget.updateToolbar(true); <del> this._activeSession.addExchange(new SessionExchange(this._activeSession.lastInput, response)); </del> <ins> this._activeSession?.addExchange(new SessionExchange(this._activeSession.lastInput, response)); </ins> this._ctxLastResponseType.set(response instanceof ReplyResponse ? response.raw.type : undefined); }


private layoutTree(): void { const scrollBarHeight = 10; <del> const treeHeight = Math.min(Math.max(266, this.editor.getLayoutInfo().height * 0.55), this.tree.contentHeight + scrollBarHeight); </del> <ins> let maxHeightToAvoidCursorOverlay = Infinity; if (this.showAtPosition) { const editorTop = this.editor.getDomNode()?.offsetTop || 0; const containerTop = this.treeContainer.offsetTop + editorTop; const hoveredCharTop = this.editor.getTopForLineNumber(this.showAtPosition.lineNumber, true) - this.editor.getScrollTop(); if (containerTop < hoveredCharTop) { maxHeightToAvoidCursorOverlay = hoveredCharTop + editorTop - 22; // 22 is monaco top padding https://github.com/microsoft/vscode/blob/a1df2d7319382d42f66ad7f411af01e4cc49c80a/src/vs/editor/browser/viewParts/contentWidgets/contentWidgets.ts#L364 } } const treeHeight = Math.min(Math.max(266, this.editor.getLayoutInfo().height * 0.55), this.tree.contentHeight + scrollBarHeight, maxHeightToAvoidCursorOverlay); </ins> const realTreeWidth = this.tree.contentWidth; const treeWidth = clamp(realTreeWidth, 400, 550);


"target" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" } } */ <del> telemetryService.publicLog('update:win32SetupTarget', { target: product.target }); </del> <ins> this.telemetryService.publicLog('update:win32SetupTarget', { target: product.target }); </ins> } }


"list.hoverBackground": "#F2F2F2", "list.focusAndSelectionOutline": "#005FB8", "menu.border": "#CECECE", <ins> "menu.selectionBackground": "#005FB8", "menu.selectionForeground": "#ffffff", </ins> "notebook.cellBorderColor": "#E5E5E5", "notebook.selectedCellBackground": "#C8DDF150", "notificationCenterHeader.background": "#FFFFFF",


this.update(); } <ins> get toggles() { return this._toggles; } set toggles(toggles: IQuickInputToggle[]) { this._toggles = toggles ?? []; this.togglesUpdated = true; this.update(); } </ins> get validationMessage() { return this._validationMessage; }


if (typeof options?.focusEditorLine === 'number') { this._cursorNavMode.set(true); this.revealInView(cell); <del> } else if (options?.revealBehavior === ScrollToRevealBehavior.fullCell) { this.revealInView(cell); </del> } else if (options?.revealBehavior === ScrollToRevealBehavior.firstLine) { this.revealFirstLineIfOutsideViewport(cell); } else {


"displayName": "Markdown it ipynb Cell Attachment renderer", "entrypoint": { "extends": "vscode.markdown-it-renderer", <del> "path": "./out/cellAttachmentRenderer.js" </del> <ins> "path": "./notebook-out/cellAttachmentRenderer.js" </ins> } } ],


// Meta if (element.saneDetail) { <ins> data.detail.element.style.display = ''; </ins> data.detail.setLabel(element.saneDetail, undefined, { matches: detailHighlights, title: element.saneDetail }); <del> } /* else { // TODO investigate potential detail bleeding into next quickpicks data.detail.setLabel(''); } */ </del> <ins> } else { data.detail.element.style.display = 'none'; } </ins> // Separator if (element.item && element.separator && element.separator.label) {


<ins> /*--------------------------------------------------------------------------------------------- *  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 * as sinon from 'sinon'; import { CancellationTokenSource, Disposable, EventEmitter, ExtensionContext, NotebookCellKind, NotebookDocumentChangeEvent, NotebookDocumentWillSaveEvent, NotebookEdit, NotebookRange, TextDocumentSaveReason, workspace, type CancellationToken, type NotebookCell, type NotebookDocument, type WorkspaceEdit, type WorkspaceEditMetadata } from 'vscode'; import { activate } from '../notebookModelStoreSync'; suite('Notebook Model Store Sync', () => { let disposables: Disposable[] = []; let onDidChangeNotebookDocument: EventEmitter<NotebookDocumentChangeEvent>; let onWillSaveNotebookDocument: AsyncEmitter<NotebookDocumentWillSaveEvent>; let notebook: NotebookDocument; let token: CancellationTokenSource; let editsApplied: WorkspaceEdit[] = []; let pendingPromises: Promise<void>[] = []; let cellMetadataUpdates: NotebookEdit[] = []; let applyEditStub: sinon.SinonStub<[edit: WorkspaceEdit, metadata?: WorkspaceEditMetadata | undefined], Thenable<boolean>>; setup(() => { disposables = []; notebook = { notebookType: '', metadata: {} } as NotebookDocument; token = new CancellationTokenSource(); disposables.push(token); sinon.stub(notebook, 'notebookType').get(() => 'jupyter-notebook'); applyEditStub = sinon.stub(workspace, 'applyEdit').callsFake((edit: WorkspaceEdit) => { editsApplied.push(edit); return Promise.resolve(true); }); const context = { subscriptions: [] as Disposable[] } as ExtensionContext; onDidChangeNotebookDocument = new EventEmitter<NotebookDocumentChangeEvent>(); disposables.push(onDidChangeNotebookDocument); onWillSaveNotebookDocument = new AsyncEmitter<NotebookDocumentWillSaveEvent>(); sinon.stub(NotebookEdit, 'updateCellMetadata').callsFake((index, metadata) => { const edit = (NotebookEdit.updateCellMetadata as any).wrappedMethod.call(NotebookEdit, index, metadata); cellMetadataUpdates.push(edit); return edit; } ); sinon.stub(workspace, 'onDidChangeNotebookDocument').callsFake(cb => onDidChangeNotebookDocument.event(cb) ); sinon.stub(workspace, 'onWillSaveNotebookDocument').callsFake(cb => onWillSaveNotebookDocument.event(cb) ); activate(context); }); teardown(async () => { await Promise.allSettled(pendingPromises); editsApplied = []; pendingPromises = []; cellMetadataUpdates = []; disposables.forEach(d => d.dispose()); disposables = []; sinon.restore(); }); test('Empty cell will not result in any updates', async () => { const e: NotebookDocumentChangeEvent = { notebook, metadata: undefined, contentChanges: [], cellChanges: [] }; onDidChangeNotebookDocument.fire(e); assert.strictEqual(editsApplied.length, 0); }); test('Adding cell for non Jupyter Notebook will not result in any updates', async () => { sinon.stub(notebook, 'notebookType').get(() => 'some-other-type'); const cell: NotebookCell = { document: {} as any, executionSummary: {}, index: 0, kind: NotebookCellKind.Code, metadata: {}, notebook, outputs: [] }; const e: NotebookDocumentChangeEvent = { notebook, metadata: undefined, contentChanges: [ { range: new NotebookRange(0, 0), removedCells: [], addedCells: [cell] } ], cellChanges: [] }; onDidChangeNotebookDocument.fire(e); assert.strictEqual(editsApplied.length, 0); assert.strictEqual(cellMetadataUpdates.length, 0); }); test('Adding cell will result in an update to the metadata', async () => { const cell: NotebookCell = { document: {} as any, executionSummary: {}, index: 0, kind: NotebookCellKind.Code, metadata: {}, notebook, outputs: [] }; const e: NotebookDocumentChangeEvent = { notebook, metadata: undefined, contentChanges: [ { range: new NotebookRange(0, 0), removedCells: [], addedCells: [cell] } ], cellChanges: [] }; onDidChangeNotebookDocument.fire(e); assert.strictEqual(editsApplied.length, 1); assert.strictEqual(cellMetadataUpdates.length, 1); const newMetadata = cellMetadataUpdates[0].newCellMetadata; assert.deepStrictEqual(newMetadata, { custom: { metadata: {} } }); }); test('Add cell id if nbformat is 4.5', async () => { sinon.stub(notebook, 'metadata').get(() => ({ custom: { nbformat: 4, nbformat_minor: 5 } })); const cell: NotebookCell = { document: {} as any, executionSummary: {}, index: 0, kind: NotebookCellKind.Code, metadata: {}, notebook, outputs: [] }; const e: NotebookDocumentChangeEvent = { notebook, metadata: undefined, contentChanges: [ { range: new NotebookRange(0, 0), removedCells: [], addedCells: [cell] } ], cellChanges: [] }; onDidChangeNotebookDocument.fire(e); assert.strictEqual(editsApplied.length, 1); assert.strictEqual(cellMetadataUpdates.length, 1); const newMetadata = cellMetadataUpdates[0].newCellMetadata || {}; assert.strictEqual(Object.keys(newMetadata).length, 1); assert.strictEqual(Object.keys(newMetadata.custom).length, 2); assert.deepStrictEqual(newMetadata.custom.metadata, {}); assert.ok(newMetadata.custom.id); }); test('Do not add cell id if one already exists', async () => { sinon.stub(notebook, 'metadata').get(() => ({ custom: { nbformat: 4, nbformat_minor: 5 } })); const cell: NotebookCell = { document: {} as any, executionSummary: {}, index: 0, kind: NotebookCellKind.Code, metadata: { custom: { id: '1234' } }, notebook, outputs: [] }; const e: NotebookDocumentChangeEvent = { notebook, metadata: undefined, contentChanges: [ { range: new NotebookRange(0, 0), removedCells: [], addedCells: [cell] } ], cellChanges: [] }; onDidChangeNotebookDocument.fire(e); assert.strictEqual(editsApplied.length, 1); assert.strictEqual(cellMetadataUpdates.length, 1); const newMetadata = cellMetadataUpdates[0].newCellMetadata || {}; assert.strictEqual(Object.keys(newMetadata).length, 1); assert.strictEqual(Object.keys(newMetadata.custom).length, 2); assert.deepStrictEqual(newMetadata.custom.metadata, {}); assert.strictEqual(newMetadata.custom.id, '1234'); }); test('Do not perform any updates if cell id and metadata exists', async () => { sinon.stub(notebook, 'metadata').get(() => ({ custom: { nbformat: 4, nbformat_minor: 5 } })); const cell: NotebookCell = { document: {} as any, executionSummary: {}, index: 0, kind: NotebookCellKind.Code, metadata: { custom: { id: '1234', metadata: {} } }, notebook, outputs: [] }; const e: NotebookDocumentChangeEvent = { notebook, metadata: undefined, contentChanges: [ { range: new NotebookRange(0, 0), removedCells: [], addedCells: [cell] } ], cellChanges: [] }; onDidChangeNotebookDocument.fire(e); assert.strictEqual(editsApplied.length, 0); assert.strictEqual(cellMetadataUpdates.length, 0); }); test('Store language id in custom metadata, whilst preserving existing metadata', async () => { sinon.stub(notebook, 'metadata').get(() => ({ custom: { nbformat: 4, nbformat_minor: 5, metadata: { language_info: { name: 'python' } } } })); const cell: NotebookCell = { document: { languageId: 'javascript' } as any, executionSummary: {}, index: 0, kind: NotebookCellKind.Code, metadata: { custom: { id: '1234', metadata: { collapsed: true, scrolled: true } } }, notebook, outputs: [] }; const e: NotebookDocumentChangeEvent = { notebook, metadata: undefined, contentChanges: [], cellChanges: [ { cell, document: undefined, metadata: undefined, outputs: undefined, executionSummary: undefined } ] }; onDidChangeNotebookDocument.fire(e); assert.strictEqual(editsApplied.length, 1); assert.strictEqual(cellMetadataUpdates.length, 1); const newMetadata = cellMetadataUpdates[0].newCellMetadata || {}; assert.strictEqual(Object.keys(newMetadata).length, 1); assert.strictEqual(Object.keys(newMetadata.custom).length, 2); assert.deepStrictEqual(newMetadata.custom.metadata, { collapsed: true, scrolled: true, vscode: { languageId: 'javascript' } }); assert.strictEqual(newMetadata.custom.id, '1234'); }); test('No changes when language is javascript', async () => { sinon.stub(notebook, 'metadata').get(() => ({ custom: { nbformat: 4, nbformat_minor: 5, metadata: { language_info: { name: 'javascript' } } } })); const cell: NotebookCell = { document: { languageId: 'javascript' } as any, executionSummary: {}, index: 0, kind: NotebookCellKind.Code, metadata: { custom: { id: '1234', metadata: { collapsed: true, scrolled: true } } }, notebook, outputs: [] }; const e: NotebookDocumentChangeEvent = { notebook, metadata: undefined, contentChanges: [], cellChanges: [ { cell, document: undefined, metadata: undefined, outputs: undefined, executionSummary: undefined } ] }; onDidChangeNotebookDocument.fire(e); assert.strictEqual(editsApplied.length, 0); assert.strictEqual(cellMetadataUpdates.length, 0); }); test('Remove language from metadata when cell language matches kernel language', async () => { sinon.stub(notebook, 'metadata').get(() => ({ custom: { nbformat: 4, nbformat_minor: 5, metadata: { language_info: { name: 'javascript' } } } })); const cell: NotebookCell = { document: { languageId: 'javascript' } as any, executionSummary: {}, index: 0, kind: NotebookCellKind.Code, metadata: { custom: { id: '1234', metadata: { vscode: { languageId: 'python' }, collapsed: true, scrolled: true } } }, notebook, outputs: [] }; const e: NotebookDocumentChangeEvent = { notebook, metadata: undefined, contentChanges: [], cellChanges: [ { cell, document: undefined, metadata: undefined, outputs: undefined, executionSummary: undefined } ] }; onDidChangeNotebookDocument.fire(e); assert.strictEqual(editsApplied.length, 1); assert.strictEqual(cellMetadataUpdates.length, 1); const newMetadata = cellMetadataUpdates[0].newCellMetadata || {}; assert.strictEqual(Object.keys(newMetadata).length, 1); assert.strictEqual(Object.keys(newMetadata.custom).length, 2); assert.deepStrictEqual(newMetadata.custom.metadata, { collapsed: true, scrolled: true }); assert.strictEqual(newMetadata.custom.id, '1234'); }); test('Update language in metadata', async () => { sinon.stub(notebook, 'metadata').get(() => ({ custom: { nbformat: 4, nbformat_minor: 5, metadata: { language_info: { name: 'javascript' } } } })); const cell: NotebookCell = { document: { languageId: 'powershell' } as any, executionSummary: {}, index: 0, kind: NotebookCellKind.Code, metadata: { custom: { id: '1234', metadata: { vscode: { languageId: 'python' }, collapsed: true, scrolled: true } } }, notebook, outputs: [] }; const e: NotebookDocumentChangeEvent = { notebook, metadata: undefined, contentChanges: [], cellChanges: [ { cell, document: undefined, metadata: undefined, outputs: undefined, executionSummary: undefined } ] }; onDidChangeNotebookDocument.fire(e); assert.strictEqual(editsApplied.length, 1); assert.strictEqual(cellMetadataUpdates.length, 1); const newMetadata = cellMetadataUpdates[0].newCellMetadata || {}; assert.strictEqual(Object.keys(newMetadata).length, 1); assert.strictEqual(Object.keys(newMetadata.custom).length, 2); assert.deepStrictEqual(newMetadata.custom.metadata, { collapsed: true, scrolled: true, vscode: { languageId: 'powershell' } }); assert.strictEqual(newMetadata.custom.id, '1234'); }); test('Will save event without any changes', async () => { await onWillSaveNotebookDocument.fireAsync({ notebook, reason: TextDocumentSaveReason.Manual }, token.token); }); test('Wait for pending updates to complete when saving', async () => { let resolveApplyEditPromise: (value: boolean) => void; const promise = new Promise<boolean>((resolve) => resolveApplyEditPromise = resolve); applyEditStub.restore(); sinon.stub(workspace, 'applyEdit').callsFake((edit: WorkspaceEdit) => { editsApplied.push(edit); return promise; }); const cell: NotebookCell = { document: {} as any, executionSummary: {}, index: 0, kind: NotebookCellKind.Code, metadata: {}, notebook, outputs: [] }; const e: NotebookDocumentChangeEvent = { notebook, metadata: undefined, contentChanges: [ { range: new NotebookRange(0, 0), removedCells: [], addedCells: [cell] } ], cellChanges: [] }; onDidChangeNotebookDocument.fire(e); assert.strictEqual(editsApplied.length, 1); assert.strictEqual(cellMetadataUpdates.length, 1); // Try to save. let saveCompleted = false; const saved = onWillSaveNotebookDocument.fireAsync({ notebook, reason: TextDocumentSaveReason.Manual }, token.token); saved.finally(() => saveCompleted = true); await new Promise((resolve) => setTimeout(resolve, 10)); // Verify we have not yet completed saving. assert.strictEqual(saveCompleted, false); resolveApplyEditPromise!(true); await new Promise((resolve) => setTimeout(resolve, 1)); // Should have completed saving. saved.finally(() => saveCompleted = true); }); interface IWaitUntil { token: CancellationToken; waitUntil(thenable: Promise<unknown>): void; } interface IWaitUntil { token: CancellationToken; waitUntil(thenable: Promise<unknown>): void; } type IWaitUntilData<T> = Omit<Omit<T, 'waitUntil'>, 'token'>; class AsyncEmitter<T extends IWaitUntil> { private listeners: ((d: T) => void)[] = []; get event(): (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => Disposable { return (listener, thisArgs, _disposables) => { this.listeners.push(listener.bind(thisArgs)); return { dispose: () => { // } }; }; } dispose() { this.listeners = []; } async fireAsync(data: IWaitUntilData<T>, token: CancellationToken): Promise<void> { if (!this.listeners.length) { return; } const promises: Promise<unknown>[] = []; this.listeners.forEach(cb => { const event = { ...data, token, waitUntil: (thenable: Promise<WorkspaceEdit>) => { promises.push(thenable); } } as T; cb(event); }); await Promise.all(promises); } } }); </ins>


} fs.writeFileSync(this.workspacesJsonPath, JSON.stringify(this.backups)); } catch (ex) { <del> console.error('Could not save workspaces.json', ex); </del> <ins> console.error(`Backup: Could not save workspaces.json: ${ex.toString()}`); </ins> } }


import { IContextKeyService, IContextKey } from 'vs/platform/contextkey/common/contextkey'; import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; import { IPanelService } from 'vs/workbench/services/panel/common/panelService'; <del> import { ITerminalInstance, KEYBINDING_CONTEXT_TERMINAL_TEXT_SELECTED, TERMINAL_PANEL_ID, IShellLaunchConfig, ITerminalProcessManager, ProcessState } from 'vs/workbench/parts/terminal/common/terminal'; </del> <ins> import { ITerminalInstance, KEYBINDING_CONTEXT_TERMINAL_TEXT_SELECTED, TERMINAL_PANEL_ID, IShellLaunchConfig, ITerminalProcessManager, ProcessState, NEVER_MEASURE_RENDER_TIME_STORAGE_KEY } from 'vs/workbench/parts/terminal/common/terminal'; </ins> import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent'; import { TabFocus } from 'vs/editor/common/config/commonEditorConfig';


}); viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, { <del> content: localize( { key: 'detectThenRunAndDebug', comment: [ 'Please do not translate the word "command", it is part of our internal syntax which must not change', '{Locked="](command:{0})"}', ] }, "[Show all automatic debug configurations](command:{0}).", SELECT_AND_START_ID), </del> <ins> content: `[${localize('detectThenRunAndDebug', "Show all automatic debug configurations")}](command:${SELECT_AND_START_ID}).`, </ins> when: CONTEXT_DEBUGGERS_AVAILABLE, group: ViewContentGroups.Debug, order: 10


.suggest-input-container .monaco-editor, .suggest-input-container .mtk1 { /* allow the embedded monaco to be styled from the outer context */ <del> background-color: inherit; </del> <ins> background-color: transparent; </ins> color: inherit; }


if (searchView.shouldShowAIResults()) { if (searchView.model.hasAIResults) { <del> viewer.expandAll(); </del> <ins> await forcedExpandRecursively(viewer, undefined); </ins> } else { <del> await viewer.expand(searchView.model.searchResult.plainTextSearchResult, true); </del> <ins> await forcedExpandRecursively(viewer, searchView.model.searchResult.plainTextSearchResult); </ins> } } else { <del> viewer.expandAll(); </del> <ins> await forcedExpandRecursively(viewer, undefined); </ins> } } } <ins> /** * Recursively expand all nodes in the search results tree that are a child of `element` * If `element` is not provided, it is the root node. */ export async function forcedExpandRecursively( viewer: WorkbenchCompressibleAsyncDataTree<SearchResult, RenderableMatch, void>, element: RenderableMatch | undefined ) { if (element) { if (!viewer.hasNode(element)) { return; } await viewer.expand(element, true); } const children = viewer.getNode(element)?.children; if (children) { for (const child of children) { if (child.element instanceof SearchResult) { throw Error('SearchResult should not be a child of a RenderableMatch'); } forcedExpandRecursively(viewer, child.element); } } } </ins> function clearSearchResults(accessor: ServicesAccessor) { const viewsService = accessor.get(IViewsService); const searchView = getSearchView(viewsService);


private async _getCommandActions(command: ITerminalCommand): Promise<IAction[]> { const actions: IAction[] = []; <ins> if (command.command !== '') { const labelRun = localize("terminal.rerunCommand", 'Rerun Command'); actions.push({ class: undefined, tooltip: labelRun, dispose: () => { }, id: 'terminal.rerunCommand', label: labelRun, enabled: true, run: () => this._onDidRequestRunCommand.fire({ command }) }); const labelCopy = localize("terminal.copyCommand", 'Copy Command'); actions.push({ class: undefined, tooltip: labelCopy, dispose: () => { }, id: 'terminal.copyCommand', label: labelCopy, enabled: true, run: () => this._clipboardService.writeText(command.command) }); } </ins> if (command.hasOutput) { <ins> if (actions.length > 0) { actions.push(new Separator()); } const labelText = localize("terminal.copyOutput", 'Copy Output'); </ins> actions.push({ <del> class: 'copy-output', tooltip: 'Copy Output', dispose: () => { }, id: 'terminal.copyOutput', label: localize("terminal.copyOutput", 'Copy Output'), enabled: true, </del> <ins> class: undefined, tooltip: labelText, dispose: () => { }, id: 'terminal.copyOutput', label: labelText, enabled: true, </ins> run: () => this._clipboardService.writeText(command.getOutput()!) }); <ins> const labelHtml = localize("terminal.copyOutputAsHtml", 'Copy Output as HTML'); </ins> actions.push({ <del> class: 'copy-output', tooltip: 'Copy Output as HTML', dispose: () => { }, id: 'terminal.copyOutputAsHtml', label: localize("terminal.copyOutputAsHtml", 'Copy Output as HTML'), enabled: true, </del> <ins> class: undefined, tooltip: labelHtml, dispose: () => { }, id: 'terminal.copyOutputAsHtml', label: labelHtml, enabled: true, </ins> run: () => this._onDidRequestRunCommand.fire({ command, copyAsHtml: true }) }); } <del> if (command.command !== '') { actions.push({ class: 'rerun-command', tooltip: 'Rerun Command', dispose: () => { }, id: 'terminal.rerunCommand', label: localize("terminal.rerunCommand", 'Rerun Command'), enabled: true, run: () => this._onDidRequestRunCommand.fire({ command }) }); </del> <ins> if (actions.length > 0) { actions.push(new Separator()); </ins> } <ins> const label = localize("terminal.learnShellIntegration", 'Learn About Shell Integration'); </ins> actions.push({ <del> class: 'how-does-this-work', tooltip: 'How does this work?', dispose: () => { }, id: 'terminal.howDoesThisWork', label: localize("terminal.howDoesThisWork", 'How does this work?'), enabled: true, </del> <ins> class: undefined, tooltip: label, dispose: () => { }, id: 'terminal.learnShellIntegration', label, enabled: true, </ins> run: () => this._openerService.open('https://code.visualstudio.com/docs/editor/integrated-terminal#_shell-integration') }); return actions;


*/ globalFindClipboard?: boolean; /** <del> * Controls whether the search automatically restarts from the beginning (or the end) when no further matches can be found </del> <ins> * Controls whether the search result and diff result automatically restarts from the beginning (or the end) when no further matches can be found </ins> */ loop?: boolean; }


abstract renderChanges(response: ReplyResponse): Promise<Position | undefined>; abstract hasFocus(): boolean; <del> abstract needsMargin(): boolean; </del> } export class PreviewStrategy extends EditModeStrategy {


resolved "https://registry.yarnpkg.com/fs-constants/-/fs-constants-1.0.0.tgz#6be0de9be998ce16af8afc24497b9ee9b7ccd9ad" integrity sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow== <ins> fs-extra@^11.2.0: version "11.2.0" resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-11.2.0.tgz#e70e17dfad64232287d01929399e0ea7c86b0e5b" integrity sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw== dependencies: graceful-fs "^4.2.0" jsonfile "^6.0.1" universalify "^2.0.0" </ins> github-from-package@0.0.0: version "0.0.0" resolved "https://registry.yarnpkg.com/github-from-package/-/github-from-package-0.0.0.tgz#97fb5d96bfde8973313f20e8288ef9a167fa64ce" integrity sha1-l/tdlr/eiXMxPyDoKI75oWf6ZM4= <del> graceful-fs@4.2.11: </del> <ins> graceful-fs@4.2.11, graceful-fs@^4.1.6, graceful-fs@^4.2.0: </ins> version "4.2.11" resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3" integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==


value: that.userDataProfileService.getShortName(profile), title: localize('change short name', "Change Short Name..."), validateInput: async (value: string) => { <del> if (profile.shortName !== value && !ThemeIcon.fromString(value) && charCount(value) > 2) { </del> <ins> if (profile.shortName === value) { return undefined; } const themeIcon = ThemeIcon.fromString(value); if (themeIcon) { if (Codicon.getAll().some(c => c.id === themeIcon.id)) { return undefined; } return localize('invalid codicon', "Invalid codicon. Please use a valid codicon id."); } if (charCount(value) > 2) { </ins> return localize('invalid short name', "Short name should be at most 2 characters long."); } return undefined;


import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions'; import { MenuRegistry } from 'vs/platform/actions/common/actions'; import { registerSingleton } from 'vs/platform/instantiation/common/extensions'; <ins> import { commandsExtensionPoint } from 'vs/workbench/api/common/menusExtensionPoint'; </ins> export class KeyboardMapperFactory { public static readonly INSTANCE = new KeyboardMapperFactory();


} /** <del> * Splits a recent label in name and parent path, supporting both '/' and '' and workspace suffixes </del> <ins> * Splits a recent label in name and parent path, supporting both '/' and '' and workspace suffixes. * If the location is remote, the remote name is included in the name part. </ins> */ <del> export function splitRecentLabel(recentLabel: string) { </del> <ins> export function splitRecentLabel(recentLabel: string): { name: string; parentPath: string } { </ins> if (recentLabel.endsWith(']')) { // label with workspace suffix const lastIndexOfSquareBracket = recentLabel.lastIndexOf(' [', recentLabel.length - 2); if (lastIndexOfSquareBracket !== -1) { const split = splitName(recentLabel.substring(0, lastIndexOfSquareBracket)); <del> return { name: split.name, parentPath: split.parentPath + recentLabel.substring(lastIndexOfSquareBracket) }; </del> <ins> const remoteNameWithSpace = recentLabel.substring(lastIndexOfSquareBracket); return { name: split.name + remoteNameWithSpace, parentPath: split.parentPath }; </ins> } } return splitName(recentLabel);


protocol: true } : undefined; <del> this._proxy.$setTunnelProvider(tunnelFeatures); </del> <ins> this._proxy.$setTunnelProvider(tunnelFeatures, !!provider.tunnelFactory); </ins> } } else { this._forwardPortProvider = undefined;


this.focus(); } <del> getContextMenuActions(): IAction[] { </del> <ins> getContextMenuActions(viewDescriptor?: IViewDescriptor): IAction[] { </ins> const result: IAction[] = []; <ins> if (viewDescriptor) { result.push(<IAction>{ id: `${viewDescriptor.id}.removeView`, label: localize('hideView', "Hide"), enabled: viewDescriptor.canToggleVisibility, run: () => this.toggleViewVisibility(viewDescriptor.id) }); } </ins> const viewToggleActions = this.viewsModel.viewDescriptors.map(viewDescriptor => (<IAction>{ id: `${viewDescriptor.id}.toggleVisibility`, label: viewDescriptor.name,


import { TestConfigurationService } from 'vs/platform/configuration/test/common/testConfigurationService'; import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock'; import { IMarkerData, IMarkerService } from 'vs/platform/markers/common/markers'; <del> import { IInlineChatService, IInlineChatSessionProvider } from 'vs/workbench/contrib/inlineChat/common/inlineChat'; </del> <ins> import { ChatAgentLocation, IChatAgent, IChatAgentData, IChatAgentService } from 'vs/workbench/contrib/chat/common/chatAgents'; </ins> import { CellDiagnostics } from 'vs/workbench/contrib/notebook/browser/contrib/cellDiagnostics/cellDiagnosticEditorContrib'; import { CodeCellViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel'; import { CellKind, NotebookSetting } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { ICellExecutionStateChangedEvent, IExecutionStateChangedEvent, INotebookCellExecution, INotebookExecutionStateService, NotebookExecutionType } from 'vs/workbench/contrib/notebook/common/notebookExecutionStateService'; import { setupInstantiationService, TestNotebookExecutionStateService, withTestNotebook } from 'vs/workbench/contrib/notebook/test/browser/testNotebookEditor'; <ins> import { nullExtensionDescription } from 'vs/workbench/services/extensions/common/extensions'; </ins> suite('notebookCellDiagnostics', () => {


withTestCodeEditor( [ <ins> 'camel from words', 'from_snake_case', 'from-kebab-case', 'alreadyCamel', 'ReTain_any_CAPitalization', 'my_var.test_function()', 'öçş_öç_şğü_ğü' ], {}, (editor) => { const model = editor.getModel()!; const camelcaseAction = new CamelCaseAction(); editor.setSelection(new Selection(1, 1, 1, 18)); executeAction(camelcaseAction, editor); assert.strictEqual(model.getLineContent(1), 'camelFromWords'); editor.setSelection(new Selection(2, 1, 2, 15)); executeAction(camelcaseAction, editor); assert.strictEqual(model.getLineContent(2), 'fromSnakeCase'); editor.setSelection(new Selection(3, 1, 3, 15)); executeAction(camelcaseAction, editor); assert.strictEqual(model.getLineContent(3), 'fromKebabCase'); editor.setSelection(new Selection(4, 1, 4, 12)); executeAction(camelcaseAction, editor); assert.strictEqual(model.getLineContent(4), 'alreadyCamel'); editor.setSelection(new Selection(5, 1, 5, 26)); executeAction(camelcaseAction, editor); assert.strictEqual(model.getLineContent(5), 'ReTainAnyCAPitalization'); editor.setSelection(new Selection(6, 1, 6, 23)); executeAction(camelcaseAction, editor); assert.strictEqual(model.getLineContent(6), 'myVar.testFunction()'); editor.setSelection(new Selection(7, 1, 7, 14)); executeAction(camelcaseAction, editor); assert.strictEqual(model.getLineContent(7), 'öçşÖçŞğüĞü'); } ); withTestCodeEditor( [ </ins> '', '   ' ], {}, (editor) => {


id: 'workbench.action.toggleZenMode', title: { value: localize('toggleZenMode', "Toggle Zen Mode"), <del> mnemonicTitle: localize('miToggleZenMode', "Zen Mode"), </del> <ins> mnemonicTitle: localize({ key: 'miToggleZenMode', comment: ['&& denotes a mnemonic'] }, "Zen Mode"), </ins> original: 'Toggle Zen Mode' }, category: Categories.View,


export const enum WorkingCopyCapabilities { /** <ins> * Signals no specific capability for the working copy. */ None = 0, /** </ins> * Signals that the working copy requires * additional input when saving, e.g. an * associated path to save to.


source: 'Git Bash' } }, <ins> additionalProperties: { 'anyOf': [ { type: 'object', required: ['source'], properties: { source: { description: localize('terminalProfile.windowsSource', 'A profile source that will auto detect the paths to the shell.'), enum: ['PowerShell', 'Git Bash'] } } }, terminalProfileSchema ] } </ins> }, 'terminal.integrated.profiles.osx': { markdownDescription: localize(


} return this.toolBar.getItemsWidth(); } <ins> dispose(): void { this.disposables = dispose(this.disposables); } </ins> } registerThemingParticipant((theme: ITheme, collector: ICssStyleCollector) => {


if (this._focused) { this._disposeFocusStickyScrollStore(); } <del> this._editor.revealPosition({ lineNumber: this._stickyScrollWidget.hoverOnLine, column: 1 }); </del> <ins> this._revealPosition({ lineNumber: this._stickyScrollWidget.hoverOnLine, column: 1 }); </ins> } this._instaService.invokeFunction(goToDefinitionWithLocation, e, this._editor as IActiveCodeEditor, { uri: this._editor.getModel()!.uri, range: this._stickyRangeProjectedOnEditor! }); } else if (!e.isRightClick) { // Normal click <del> const position = { lineNumber: this._stickyScrollWidget.hoverOnLine, column: this._stickyScrollWidget.hoverOnColumn }; </del> if (this._focused) { this._disposeFocusStickyScrollStore(); } <del> this._editor.revealPosition(position); this._editor.setSelection(Range.fromPositions(position)); </del> <ins> this._revealPosition({ lineNumber: this._stickyScrollWidget.hoverOnLine, column: this._stickyScrollWidget.hoverOnColumn }); </ins> } })); return linkGestureStore;


import { IChatEditorOptions } from '../chatEditor.js'; import { ChatEditorInput } from '../chatEditorInput.js'; import { ChatViewPane } from '../chatViewPane.js'; <del> import { CONTEXT_CHAT_ENABLED, CONTEXT_CHAT_INPUT_CURSOR_AT_TOP, CONTEXT_IN_CHAT_INPUT, CONTEXT_IN_CHAT_SESSION } from '../../common/chatContextKeys.js'; </del> <ins> import { CONTEXT_CHAT_ENABLED, CONTEXT_CHAT_INPUT_CURSOR_AT_TOP, CONTEXT_IN_CHAT_INPUT, CONTEXT_IN_CHAT_SESSION, CONTEXT_IN_QUICK_CHAT } from '../../common/chatContextKeys.js'; </ins> import { IChatDetail, IChatService } from '../../common/chatService.js'; import { IChatRequestViewModel, IChatResponseViewModel, isRequestVM } from '../../common/chatViewModel.js'; import { IChatWidgetHistoryService } from '../../common/chatWidgetHistoryService.js';


constructor( private readonly _collection: IMergedEnvironmentVariableCollection, <del> @ICommandService private readonly _commandService: ICommandService </del> <ins> @ICommandService private readonly _commandService: ICommandService, @IExtensionService private readonly _extensionService: IExtensionService </ins> ) { }


this.configurationProperties[key] = property; this.defaultLanguageConfigurationOverridesNode.properties![key] = property; } else { <ins> this.defaultValues[key] = defaultConfiguration[key]; </ins> const property = this.configurationProperties[key]; if (property) { this.updatePropertyDefaultValue(key, property);


"config.branchProtectionPrompt.alwaysCommit": "Always commit changes to the protected branch.", "config.branchProtectionPrompt.alwaysCommitToNewBranch": "Always commit changes to a new branch.", "config.branchProtectionPrompt.alwaysPrompt": "Always prompt before changes are committed to a protected branch.", <del> "config.branchRandomNameDictionary": "List of dictionaries used when the branch name that is randomly generated. Supported values: `adjectives`, `animals`, `colors`, `numbers`.", </del> <ins> "config.branchRandomNameDictionary": "List of dictionaries used for the randomly generated branch name. Each value represents the dictionary used to generate the segment of the branch name. Supported dictionaries: `adjectives`, `animals`, `colors` and `numbers`.", "config.branchRandomNameDictionary.adjectives": "A random adjective", "config.branchRandomNameDictionary.animals": "A random animal name", "config.branchRandomNameDictionary.colors": "A random color name", "config.branchRandomNameDictionary.numbers": "A random number between 100 and 999", </ins> "config.branchRandomNameEnable": "Controls whether a random name is generated when creating a new branch.", "config.branchValidationRegex": "A regular expression to validate new branch names.", "config.branchWhitespaceChar": "The character to replace whitespace in new branch names, and to separate segments of a randomly generated branch name.",


super.dispose(); this._subscriptions = dispose(this._subscriptions); } <del> } </del>  No newline at end of file <ins> } </ins>


} dispose(): void { <ins> this._quickDiff?.dispose(); </ins> } }


font-family: 'codicon'; content: 'eb53'; background-image: none; <del> font-size: 150%; </del> <ins> font-size: 16px; line-height: 37px !important; </ins> } .workspace-trust-editor {


collector.addRule(` .monaco-editor .contentWidgets ${Codicon.lightbulbAutofix.cssSelector} { color: ${editorLightBulbAutoFixForegroundColor}; <ins> background-color: ${editorBackgroundColor}; </ins> }`); }


super(VIEWLET_ID, { mergeViewWithContainerWhenSingleView: true }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService); <del> this.viewletVisibleContextKey = ExplorerViewletVisibleContext.bindTo(contextKeyService); </del> this._register(this.contextService.onDidChangeWorkspaceName(e => this.updateTitleArea())); }


"git": { "name": "electron", "repositoryUrl": "https://github.com/electron/electron", <del> "commitHash": "84d7f7f071ae11637d4a41b95536410293672750" </del> <ins> "commitHash": "dc3ce65dd5fd872db86e5308ae005a898142435a" </ins> } }, "isOnlyProductionDependency": true, "license": "MIT", <del> "version": "25.8.0" </del> <ins> "version": "25.8.1" </ins> }, { "component": {


env: this._shellLaunchConfig.env }; <del> this._logService.trace('Spawning remote agent process', { terminalId: this.id, shellLaunchConfigDto }); </del> <ins> this._logService.trace('Spawning remote agent process', { terminalId: this._instanceId, shellLaunchConfigDto }); </ins> const result = await this._remoteTerminalChannel.createTerminalProcess( shellLaunchConfigDto,


import * as strings from 'vs/base/common/strings'; import * as objects from 'vs/base/common/objects'; import * as platform from 'vs/base/common/platform'; <del> import * as stdfork from 'vs/base/node/stdFork'; </del> import { Emitter, Event } from 'vs/base/common/event'; import { TPromise } from 'vs/base/common/winjs.base'; import { ExtensionsChannelId } from 'vs/platform/extensionManagement/common/extensionManagement';


getSelectedOrSuggestedKernel(notebook: INotebookTextModel): INotebookKernel | undefined { const info = this.getMatchingKernel(notebook); <del> return info.selected ?? (info.all.length === 1 ? info.all[0] : undefined); </del> <ins> if (info.selected) { return info.selected; } const preferred = info.all.filter(kernel => this._kernels.get(kernel.id)?.notebookPriorities.get(notebook.uri) === 2 /* vscode.NotebookControllerPriority.Preferred */); if (preferred.length === 1) { return preferred[0]; } return info.all.length === 1 ? info.all[0] : undefined; </ins> } // default kernel for notebookType


} run(accessor: ServicesAccessor) { accessor.get(ITerminalService).doWithActiveInstance(t => { <del> t.xterm?.markTracker.scrollToPreviousMark(); </del> <ins> t.xterm?.markTracker.scrollToPreviousMark(undefined, undefined, t.capabilities.has(TerminalCapability.CommandDetection)); </ins> }); } });


public async run(accessor: ServicesAccessor | undefined, editor: ICodeEditor): Promise<void> { const controller = InlineCompletionsController.get(editor); <del> controller?.model.get()?.acceptNextLine(controller.editor); </del> <ins> await controller?.model.get()?.acceptNextLine(controller.editor); </ins> } }


import { Slugifier } from './slugify'; import { ITextDocument } from './types/textDocument'; import { Disposable } from './util/dispose'; <del> import { stringHash } from './util/hash'; </del> import { WebviewResourceProvider } from './util/resources'; import { isOfScheme, Schemes } from './util/schemes'; import { MdDocumentInfoCache } from './util/workspaceCache';


private addLinkValidator(md: any): void { const validateLink = md.validateLink; md.validateLink = (link: string) => { <del> // support file:// links </del> return validateLink(link) <del> || isOfScheme(Schemes.file, link) </del> || isOfScheme(Schemes.vscode, link) || isOfScheme(Schemes['vscode-insiders'], link) || /^data:image/.*?;/.test(link);


import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService'; import { toErrorMessage } from 'vs/base/common/errorMessage'; import { IListService } from 'vs/platform/list/browser/listService'; <del> import { CommandsRegistry, ICommandHandler } from 'vs/platform/commands/common/commands'; </del> <ins> import { CommandsRegistry, ICommandHandler, ICommandService } from 'vs/platform/commands/common/commands'; </ins> import { IContextKey, IContextKeyService, ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey'; import { IFileService } from 'vs/platform/files/common/files'; import { KeybindingsRegistry, KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry';


"description": "%configuration.suggest.includeCompletionsForImportStatements%", "scope": "resource" }, <del> "typescript.suggest.includeCompletionsWithSnippetText": { "type": "boolean", "default": true, "description": "%configuration.suggest.includeCompletionsWithSnippetText%", "scope": "resource" }, </del> "typescript.reportStyleChecksAsWarnings": { "type": "boolean", "default": true,


"--vscode-activityBarTop-foreground", "--vscode-activityBarTop-inactiveForeground", "--vscode-activityBarTop-background", <ins> "--vscode-activityBarTop-activeBackground", </ins> "--vscode-badge-background", "--vscode-badge-foreground", "--vscode-banner-background",


} kbd { <del> color: var(--vscode-editor-foreground); </del> <ins> background-color: var(--vscode-keybindingLabel-background); color: var(--vscode-keybindingLabel-foreground); border-style: solid; border-width: 1px; </ins> border-radius: 3px; <ins> border-color: var(--vscode-keybindingLabel-border); border-bottom-color: var(--vscode-keybindingLabel-bottomBorder); box-shadow: inset 0 -1px 0 var(--vscode-widget-shadow); </ins> vertical-align: middle; padding: 1px 3px; <del> background-color: hsla(0,0%,50%,.17); border: 1px solid rgba(71,71,71,.4); border-bottom-color: rgba(88,88,88,.4); box-shadow: inset 0 -1px 0 rgba(88,88,88,.4); } .vscode-light kbd { background-color: hsla(0,0%,87%,.5); border: 1px solid hsla(0,0%,80%,.7); border-bottom-color: hsla(0,0%,73%,.7); box-shadow: inset 0 -1px 0 hsla(0,0%,73%,.7); </del> } ::-webkit-scrollbar {


templateData.button.element.style.display = 'none'; templateData.button.dispose(); } <ins> templateData.elementDisposable.dispose(); </ins> let editableData: IEditableData | undefined; if (element.editId === TunnelEditId.New && (editableData = this.remoteExplorerService.getEditableData(undefined))) {


*--------------------------------------------------------------------------------------------*/ import * as assert from 'assert'; import { isWindows } from 'vs/base/common/platform'; <del> import { URI, UriComponents } from 'vs/base/common/uri'; </del> <ins> import { URI, UriComponents, isUriComponents } from 'vs/base/common/uri'; </ins> suite('URI', () => {


<del> <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <plist version="1.0"> <dict> <key>fileTypes</key> <array> <string>ini</string> <string>conf</string> </array> <key>keyEquivalent</key> <string>^~I</string> <key>name</key> <string>Ini</string> <key>patterns</key> <array> <dict> <key>begin</key> <string>(^[ t]+)?(?=#)</string> <key>beginCaptures</key> <dict> <key>1</key> <dict> <key>name</key> <string>punctuation.whitespace.comment.leading.ini</string> </dict> </dict> <key>end</key> <string>(?!G)</string> <key>patterns</key> <array> <dict> <key>begin</key> <string>#</string> <key>beginCaptures</key> <dict> <key>0</key> <dict> <key>name</key> <string>punctuation.definition.comment.ini</string> </dict> </dict> <key>end</key> <string>n</string> <key>name</key> <string>comment.line.number-sign.ini</string> </dict> </array> </dict> <dict> <key>begin</key> <string>(^[ t]+)?(?=;)</string> <key>beginCaptures</key> <dict> <key>1</key> <dict> <key>name</key> <string>punctuation.whitespace.comment.leading.ini</string> </dict> </dict> <key>end</key> <string>(?!G)</string> <key>patterns</key> <array> <dict> <key>begin</key> <string>;</string> <key>beginCaptures</key> <dict> <key>0</key> <dict> <key>name</key> <string>punctuation.definition.comment.ini</string> </dict> </dict> <key>end</key> <string>n</string> <key>name</key> <string>comment.line.semicolon.ini</string> </dict> </array> </dict> <dict> <key>captures</key> <dict> <key>1</key> <dict> <key>name</key> <string>keyword.other.definition.ini</string> </dict> <key>2</key> <dict> <key>name</key> <string>punctuation.separator.key-value.ini</string> </dict> </dict> <key>match</key> <string>b([a-zA-Z0-9_.-]+)bs*(=)</string> </dict> <dict> <key>captures</key> <dict> <key>1</key> <dict> <key>name</key> <string>punctuation.definition.entity.ini</string> </dict> <key>3</key> <dict> <key>name</key> <string>punctuation.definition.entity.ini</string> </dict> </dict> <key>match</key> <string>^([)(.*?)(])</string> <key>name</key> <string>entity.name.section.group-title.ini</string> </dict> <dict> <key>begin</key> <string>'</string> <key>beginCaptures</key> <dict> <key>0</key> <dict> <key>name</key> <string>punctuation.definition.string.begin.ini</string> </dict> </dict> <key>end</key> <string>'</string> <key>endCaptures</key> <dict> <key>0</key> <dict> <key>name</key> <string>punctuation.definition.string.end.ini</string> </dict> </dict> <key>name</key> <string>string.quoted.single.ini</string> <key>patterns</key> <array> <dict> <key>match</key> <string>.</string> <key>name</key> <string>constant.character.escape.ini</string> </dict> </array> </dict> <dict> <key>begin</key> <string>"</string> <key>beginCaptures</key> <dict> <key>0</key> <dict> <key>name</key> <string>punctuation.definition.string.begin.ini</string> </dict> </dict> <key>end</key> <string>"</string> <key>endCaptures</key> <dict> <key>0</key> <dict> <key>name</key> <string>punctuation.definition.string.end.ini</string> </dict> </dict> <key>name</key> <string>string.quoted.double.ini</string> </dict> </array> <key>scopeName</key> <string>source.ini</string> <key>uuid</key> <string>77DC23B6-8A90-11D9-BAA4-000A9584EC8C</string> </dict> </plist> </del>  No newline at end of file


import { DisposableStore } from 'vs/base/common/lifecycle'; import { CellUri } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { disposableTimeout } from 'vs/base/common/async'; <del> import { IPaneCompositePartService } from 'vs/workbench/services/panecomposite/browser/panecomposite'; import { ViewContainerLocation } from 'vs/workbench/common/views'; </del> import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace'; import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil'; import { isEmptyObject } from 'vs/base/common/types'; import { PLAINTEXT_LANGUAGE_ID } from 'vs/editor/common/languages/modesRegistry'; <del> type FileExtensionSuggestionClassification = { owner: 'sandy081'; comment: 'Response information when a file based reccommendation is suggested'; userReaction: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'User reaction after showing the recommendation prompt. Eg., install, cancel, show, neverShowAgain' }; fileExtension: { classification: 'PublicNonPersonalData'; purpose: 'FeatureInsight'; comment: 'Extension of the file for which an extension is being recommended.' }; }; </del> const promptedRecommendationsStorageKey = 'fileBasedRecommendations/promptedRecommendations'; <del> const promptedFileExtensionsStorageKey = 'fileBasedRecommendations/promptedFileExtensions'; </del> const recommendationsStorageKey = 'extensionsAssistant/recommendations'; <del> const searchMarketplace = localize('searchMarketplace', "Search Marketplace"); </del> const milliSecondsInADay = 1000 * 60 * 60 * 24; export class FileBasedRecommendations extends ExtensionRecommendations {


import { Context as SuggestContext } from 'vs/editor/contrib/suggest/browser/suggest'; import { AsyncIterableObject } from 'vs/base/common/async'; import { EditorContextKeys } from 'vs/editor/common/editorContextKeys'; <ins> import { ResizableHoverWidget } from 'vs/editor/contrib/hover/browser/resizableHoverWidget'; </ins> const $ = dom.$; export class ContentHoverController extends Disposable { private readonly _participants: IEditorHoverParticipant[]; <del> private readonly _widget = this._register(this._instantiationService.createInstance(ContentHoverWidget, this._editor)); </del> <ins> // INITIALLY: private readonly _widget = this._register(this._instantiationService.createInstance(ContentHoverWidget, this._editor)); private readonly _widget; </ins> private readonly _computer: ContentHoverComputer; private readonly _hoverOperation: HoverOperation<IHoverPart>;


display: none; } <del> .monaco-tree.focused .selected .outline-element-label, .monaco-tree.focused .selected .outline-element-decoration { </del> <ins> .monaco-tree.focused .selected .outline-element-label, .monaco-tree.focused .selected .outline-element-decoration{ </ins> /* make sure selection color wins when a label is being selected */ color: inherit !important; } <ins> .monaco-tree.focused .selected .outline-element-label .monaco-highlighted-label .highlight, .monaco-tree.focused .selected .monaco-icon-label .monaco-highlighted-label .highlight{ /* allows text color to use the default when selected  */ color: inherit !important; } </ins> .monaco-workbench .outline-panel.no-icons .outline-element .outline-element-icon { display: none; }


extendMarkdownIt(md: any) { if (isEnabled()) { const katex = require('@vscode/markdown-it-katex'); <del> const options = { globalGroup: true, macros: {} }; md.core.ruler.push('reset-katex-macros', () => { options.macros = {}; }); </del> <ins> const settingsMacros = getMacros(); const options = { globalGroup: true, macros: { ...settingsMacros } }; md.core.ruler.push('reset-katex-macros', () => { options.macros = { ...settingsMacros }; }); </ins> return md.use(katex, options); } return md;


invokeProtocolHandler(); const showProtocolUrlOpenedDialog = async () => { <ins> const { downloadUrl } = this.productService; let detail = localize( 'openExternalDialogDetail.v2', "We launched {0} on your computer.nnIf {1} did not launch, try again or install it below.", this.productService.nameLong, this.productService.nameLong ); const options = [ localize('openExternalDialogButtonClose', "Close tab"), localize('openExternalDialogButtonRetry', "Try again"), localize('openExternalDialogButtonInstall.v3', "Install"), localize('openExternalDialogButtonCancel', "Cancel") ]; if (downloadUrl === undefined) { options.splice(2, 1); detail = localize( 'openExternalDialogDetailNoInstall', "We launched {0} on your computer.nnIf {1} did not launch, try again below.", this.productService.nameLong, this.productService.nameLong ); } </ins> const showResult = await this.dialogService.show( Severity.Info, localize('openExternalDialogTitle', "All done. You can close this tab now."), <del> [ localize('openExternalDialogButtonRetry', "Try again"), localize('openExternalDialogButtonInstall', "Install {0}", this.productService.nameLong), localize('openExternalDialogButtonCancel', "Cancel") ], </del> <ins> options, </ins> { <del> cancelId: 2, detail: localize( 'openExternalDialogDetail.v2', "We launched {0} on your computer.nnIf {1} did not launch, try again or install it below.", this.productService.nameLong, this.productService.nameLong, ) </del> <ins> cancelId: downloadUrl === undefined ? 2 : 3, detail </ins> }, ); if (showResult.choice === 0) { <del> invokeProtocolHandler(); </del> <ins> this.hostService.close(); </ins> } else if (showResult.choice === 1) { <del> // Route the user to the appropriate install link await this.openerService.open(URI.parse( this.productService.quality === 'stable' ? `http://aka.ms/vscode-install` : `http://aka.ms/vscode-install-insiders` )); </del> <ins> invokeProtocolHandler(); } else if (showResult.choice === 2 && downloadUrl !== undefined) { await this.openerService.open(URI.parse(downloadUrl)); </ins> // Re-show the dialog so that the user can come back after installing and try again showProtocolUrlOpenedDialog();


@IWorkspaceContextService private readonly workspaceContextService: IWorkspaceContextService, @IEditorGroupsService private readonly editorGroupsService: IEditorGroupsService, @ILogService private readonly logService: ILogService, <del> @IPathService private readonly pathService: IPathService </del> <ins> @IPathService private readonly pathService: IPathService, @IUriIdentityService protected readonly uriIdentityService: IUriIdentityService </ins> ) { }


resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8= <del> xterm-addon-canvas@0.4.0-beta.7: version "0.4.0-beta.7" resolved "https://registry.yarnpkg.com/xterm-addon-canvas/-/xterm-addon-canvas-0.4.0-beta.7.tgz#ae365d8e10c900292186529f70f7f275ac94b3d5" integrity sha512-r1hbQTsulI49orR5G3qWrJCwn2dKsEUCrgj6xsmgXuTeoUcGfed6lly+MvYlL3P8aPrxS2fC2TEzSM0Au4SX+w== </del> <ins> xterm-addon-canvas@0.4.0-beta.9: version "0.4.0-beta.9" resolved "https://registry.yarnpkg.com/xterm-addon-canvas/-/xterm-addon-canvas-0.4.0-beta.9.tgz#e570fa4592890f92cc86706f2bba0dd128a8641d" integrity sha512-BWRVWyUW7NY2g4BBMm3ecPQvbdyKXFgABnpmh4m0TVHqFJMNeXdNuTc94KiDbE+cvw8jtAY9NC/OIM4HcgjAIQ== </ins> xterm-addon-search@0.11.0: version "0.11.0"


import { IListService, IWorkbenchListOptions, WorkbenchList } from 'vs/platform/list/browser/listService'; import { CursorAtBoundary, ICellViewModel, CellEditState, CellFocusMode, ICellOutputViewModel, CellRevealType, CellRevealSyncType, CellRevealRangeType, CursorAtLineBoundary } from 'vs/workbench/contrib/notebook/browser/notebookBrowser'; import { CellViewModel, NotebookViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/notebookViewModelImpl'; <del> import { diff, NOTEBOOK_EDITOR_CURSOR_BOUNDARY, CellKind, SelectionStateType, NOTEBOOK_EDITOR_CURSOR_LINE_BOUNDARY } from 'vs/workbench/contrib/notebook/common/notebookCommon'; </del> <ins> import { diff, NOTEBOOK_EDITOR_CURSOR_BOUNDARY, CellKind, SelectionStateType, NOTEBOOK_EDITOR_CURSOR_LINE_BOUNDARY, NotebookSetting } from 'vs/workbench/contrib/notebook/common/notebookCommon'; </ins> import { ICellRange, cellRangesToIndexes, reduceCellRanges, cellRangesEqual } from 'vs/workbench/contrib/notebook/common/notebookRange'; import { NOTEBOOK_CELL_LIST_FOCUSED } from 'vs/workbench/contrib/notebook/common/notebookContextKeys'; import { clamp } from 'vs/base/common/numbers';


if (this.adapterExecutable.command === 'node' && this.outputService) { if (Array.isArray(this.adapterExecutable.args) && this.adapterExecutable.args.length > 0) { <del> stdfork.fork(this.adapterExecutable.args[0], this.adapterExecutable.args.slice(1), {}, (err, child) => { if (err) { e(new Error(nls.localize('unableToLaunchDebugAdapter', "Unable to launch debug adapter from '{0}'.", this.adapterExecutable.args[0]))); } this.serverProcess = child; c(null); </del> <ins> const child = cp.fork(this.adapterExecutable.args[0], this.adapterExecutable.args.slice(1), { execArgv: ['-e', 'delete process.env.ELECTRON_RUN_AS_NODE;require(process.argv[1])'].concat(process.execArgv || []), silent: true </ins> }); <ins> if (!child.pid) { e(new Error(nls.localize('unableToLaunchDebugAdapter', "Unable to launch debug adapter from '{0}'.", this.adapterExecutable.args[0]))); } this.serverProcess = child; c(null); </ins> } else { e(new Error(nls.localize('unableToLaunchDebugAdapterNoArgs', "Unable to launch debug adapter."))); }


const document = await vscode.workspace.openTextDocument(newUri); assert.strictEqual(document.isDirty, true); <del> await document.save(); assert.strictEqual(document.isDirty, false); </del> <ins> const result = await document.save(); assert.strictEqual(result, true, `save failed in iteration: ${i} (docUriOriginal: ${docUriOriginal.fsPath})`); assert.strictEqual(document.isDirty, false, `document still dirty in iteration: ${i} (docUriOriginal: ${docUriOriginal.fsPath})`); </ins> assert.strictEqual(document.getText(), expected);


const testDocument = workspaceFile('bower.json'); <del> // Disable webview tests on web (vscode.env.uiKind === vscode.UIKind.Web ? suite.skip : suite)('vscode API - webview', () => { </del> <ins> suite('vscode API - webview', () => { </ins> const disposables: vscode.Disposable[] = []; function _register<T extends vscode.Disposable>(disposable: T) {


throw new Error('Please sign in to store your edit session.'); } <ins> if (editSession.machine === undefined) { editSession.machine = await this.getOrCreateCurrentMachineId(); } </ins> return this.storeClient!.writeResource('editSessions', JSON.stringify(editSession), null, undefined, createSyncHeaders(generateUuid())); }


if (options?.instanceToSplit && typeof shellLaunchConfig.cwd !== 'object' && typeof options.instanceToSplit.shellLaunchConfig.cwd === 'object') { shellLaunchConfig.cwd = URI.from({ scheme: options.instanceToSplit.shellLaunchConfig.cwd.scheme, <ins> authority: options.instanceToSplit.shellLaunchConfig.cwd.authority, </ins> path: shellLaunchConfig.cwd || options.instanceToSplit.shellLaunchConfig.cwd.path }); }


// High Contrast Events ipc.on('vscode:enterHighContrast', (event) => { <del> this.partService.joinCreation().then(() => { this.themeService.setColorTheme(VS_HC_THEME, false); }); </del> <ins> const windowConfig = this.configurationService.getConfiguration<IWindowSettings>('window'); if (windowConfig && windowConfig.autoDetectHighContrast) { this.partService.joinCreation().then(() => { this.themeService.setColorTheme(VS_HC_THEME, false); }); } </ins> }); ipc.on('vscode:leaveHighContrast', (event) => { <del> this.partService.joinCreation().then(() => { this.themeService.setColorTheme(VS_DARK_THEME, false); }); </del> <ins> const windowConfig = this.configurationService.getConfiguration<IWindowSettings>('window'); if (windowConfig && windowConfig.autoDetectHighContrast) { this.partService.joinCreation().then(() => { this.themeService.setColorTheme(VS_DARK_THEME, false); }); } </ins> }); // Configuration changes


/** Ellipsis on hover **/ <del> .monaco-editor .suggest-widget:not(.docs-side) .monaco-list .monaco-list-row:hover>.contents>.main>.right.can-expand-details>.details-label { </del> <ins> .monaco-editor .suggest-widget:not(.docs-side) .monaco-list .monaco-list-row.focused:hover>.contents>.main>.right.can-expand-details>.details-label { </ins> width: calc(100% - 26px); }


await p2; }); <ins> test('Ranges where additionalTextEdits are applied are not appropriate when characters are typed #177591', async function () { disposables.add(languageFeaturesService.completionProvider.register({ scheme: 'test-ctrl' }, { _debugDisplayName: 'test', provideCompletionItems(doc, pos) { return { suggestions: [{ kind: CompletionItemKind.Snippet, label: 'aaa', insertText: 'aaa', range: Range.fromPositions(pos), additionalTextEdits: [{ range: Range.fromPositions(pos.delta(0, 10)), text: 'aaa' }] }] }; } })); { // PART1 - no typing editor.setValue(`123456789123456789`); editor.setSelection(new Selection(1, 1, 1, 1)); const p1 = Event.toPromise(controller.model.onDidSuggest); controller.triggerSuggest(); const e = await p1; assert.strictEqual(e.completionModel.items.length, 1); assert.strictEqual(e.completionModel.items[0].textLabel, 'aaa'); controller.acceptSelectedSuggestion(false, false); assert.strictEqual(editor.getValue(), 'aaa1234567891aaa23456789'); } { // PART2 - typing editor.setValue(`123456789123456789`); editor.setSelection(new Selection(1, 1, 1, 1)); const p1 = Event.toPromise(controller.model.onDidSuggest); controller.triggerSuggest(); const e = await p1; assert.strictEqual(e.completionModel.items.length, 1); assert.strictEqual(e.completionModel.items[0].textLabel, 'aaa'); editor.trigger('keyboard', 'type', { text: 'aa' }); controller.acceptSelectedSuggestion(false, false); assert.strictEqual(editor.getValue(), 'aaa1234567891aaa23456789'); } }); </ins> });


} # Debug trapping/preexec inspired by starship (ISC) <del> __vsc_dbg_trap="$(trap -p DEBUG | cut -d' ' -f3 | tr -d ')" if [[ -z "$__vsc_dbg_trap" ]]; then </del> <ins> if [[ -n "${bash_preexec_imported:-}" ]]; then </ins> __vsc_preexec_only() { __vsc_status="$?" __vsc_preexec } <del> trap '__vsc_preexec_only "$_"' DEBUG elif [[ "$__vsc_dbg_trap" != '__vsc_preexec "$_"' && "$__vsc_dbg_trap" != '__vsc_preexec_all "$_"' ]]; then __vsc_preexec_all() { __vsc_status="$?" builtin eval ${__vsc_dbg_trap} __vsc_preexec } trap '__vsc_preexec_all "$_"' DEBUG </del> <ins> precmd_functions+=(__vsc_prompt_cmd) preexec_functions+=(__vsc_preexec_only) else __vsc_dbg_trap="$(trap -p DEBUG | cut -d' ' -f3 | tr -d ')" if [[ -z "$__vsc_dbg_trap" ]]; then __vsc_preexec_only() { __vsc_status="$?" __vsc_preexec } trap '__vsc_preexec_only "$_"' DEBUG elif [[ "$__vsc_dbg_trap" != '__vsc_preexec "$_"' && "$__vsc_dbg_trap" != '__vsc_preexec_all "$_"' ]]; then __vsc_preexec_all() { __vsc_status="$?" builtin eval ${__vsc_dbg_trap} __vsc_preexec } trap '__vsc_preexec_all "$_"' DEBUG fi </ins> fi __vsc_update_prompt


} }); <del> const task = this._activeSession.provider.provideResponse(this._activeSession.session, request, progress, requestCts.token); </del> <ins> const task = this._activeSession.provider.provideResponse(this._activeSession.session, request, progress, this._activeRequestCts.token); </ins> let response: ReplyResponse | ErrorResponse | EmptyResponse; try {


import { IViewContainersRegistry, ViewContainerLocation, Extensions as ViewContainerExtensions, IViewsService } from 'vs/workbench/common/views'; import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService'; import { IPreferencesService } from 'vs/workbench/services/preferences/common/preferences'; <del> import { ContextKeyExpr, IContextKeyService, RawContextKey } from 'vs/platform/contextkey/common/contextkey'; </del> <ins> import { ContextKeyDefinedExpr, ContextKeyExpr, IContextKeyService, RawContextKey } from 'vs/platform/contextkey/common/contextkey'; </ins> import { IQuickAccessRegistry, Extensions } from 'vs/platform/quickinput/common/quickAccess'; import { InstallExtensionQuickAccessProvider, ManageExtensionsQuickAccessProvider } from 'vs/workbench/contrib/extensions/browser/extensionsQuickAccess'; import { ExtensionRecommendationsService } from 'vs/workbench/contrib/extensions/browser/extensionRecommendationsService';


import { Handler } from 'vs/editor/common/editorCommon'; import { ITextModel } from 'vs/editor/common/model'; import { ViewModel } from 'vs/editor/common/viewModel/viewModelImpl'; <del> import { DeleteAllLeftAction, DeleteAllRightAction, DeleteDuplicateLinesAction, DeleteLinesAction, IndentLinesAction, InsertLineAfterAction, InsertLineBeforeAction, JoinLinesAction, KebabCaseAction, LowerCaseAction, SnakeCaseAction, SortLinesAscendingAction, SortLinesDescendingAction, TitleCaseAction, TransposeAction, UpperCaseAction } from 'vs/editor/contrib/linesOperations/browser/linesOperations'; </del> <ins> import { CamelCaseAction, DeleteAllLeftAction, DeleteAllRightAction, DeleteDuplicateLinesAction, DeleteLinesAction, IndentLinesAction, InsertLineAfterAction, InsertLineBeforeAction, JoinLinesAction, KebabCaseAction, LowerCaseAction, SnakeCaseAction, SortLinesAscendingAction, SortLinesDescendingAction, TitleCaseAction, TransposeAction, UpperCaseAction } from 'vs/editor/contrib/linesOperations/browser/linesOperations'; </ins> import { withTestCodeEditor } from 'vs/editor/test/browser/testCodeEditor'; import { createTextModel } from 'vs/editor/test/common/testTextModel';


if (docUri.scheme === Schemes.untitled) { return vscode.workspace.workspaceFolders?.[0]?.uri; } <del> return docUri; </del> <ins> return Utils.dirname(docUri); </ins> } async function insertLink(activeEditor: vscode.TextEditor, selectedFiles: vscode.Uri[], insertAsImage: boolean): Promise<void> {


"workspaceTrust", "telemetry", "windowActivity", <del> "interactiveUserActions" </del> <ins> "interactiveUserActions", "envCollectionWorkspace", "envCollectionOptions" </ins> ], "private": true, "activationEvents": [],


resolved "https://registry.yarnpkg.com/jschardet/-/jschardet-3.0.0.tgz#898d2332e45ebabbdb6bf2feece9feea9a99e882" integrity sha512-lJH6tJ77V8Nzd5QWRkFYCLc13a3vADkh3r/Fi8HupZGWk2OVVDfnZP8V/VgQgZ+lzW0kG2UGb5hFgt3V3ndotQ== <ins> jsonfile@^6.0.1: version "6.1.0" resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae" integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ== dependencies: universalify "^2.0.0" optionalDependencies: graceful-fs "^4.1.6" </ins> kerberos@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/kerberos/-/kerberos-2.0.1.tgz#663b0b46883b4da84495f60f2e9e399a43a33ef5"


} .monaco-hover .markdown-hover > .hover-contents:not(.code-hover-contents) { <del> max-width: 500px; </del> word-wrap: break-word; }


} // Open based on config <del> const { windows: usedWindows, filesOpenedInWindow } = await this.doOpen(openConfig, workspacesToOpen, foldersToOpen, emptyWindowsWithBackupsToRestore, emptyToOpen, filesToOpen, foldersToAdd); </del> <ins> const { windows: usedWindows, filesOpenedInWindow } = await this.doOpen(openConfig, workspacesToOpen, foldersToOpen, emptyWindowsWithBackupsToRestore, openOneEmptyWindow, filesToOpen, foldersToAdd); </ins> <del> this.logService.trace(`windowsManager#open used window count ${usedWindows.length} (workspacesToOpen: ${workspacesToOpen.length}, foldersToOpen: ${foldersToOpen.length}, emptyToRestore: ${emptyWindowsWithBackupsToRestore.length}, emptyToOpen: ${emptyToOpen})`); </del> <ins> this.logService.trace(`windowsManager#open used window count ${usedWindows.length} (workspacesToOpen: ${workspacesToOpen.length}, foldersToOpen: ${foldersToOpen.length}, emptyToRestore: ${emptyWindowsWithBackupsToRestore.length}, openOneEmptyWindow: ${openOneEmptyWindow})`); </ins> // Make sure to pass focus to the most relevant of the windows if we open multiple if (usedWindows.length > 1) {


/usr/share/@@NAME@@/ /usr/share/applications/@@NAME@@.desktop <ins> /usr/share/applications/@@NAME@@-url-handler.desktop </ins> /usr/share/pixmaps/@@NAME@@.png