<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ import { HoverWidget } from 'vs/base/browser/ui/hover/hoverWidget'; import { DisposableStore } from 'vs/base/common/lifecycle'; import { ContentWidgetPositionPreference, ICodeEditor, IContentWidgetPosition } from 'vs/editor/browser/editorBrowser'; import { EditorContextKeys } from 'vs/editor/common/editorContextKeys'; import { MultipleSizePersistingOptions, ResizableContentWidget, ResizableWidget } from 'vs/editor/contrib/hover/browser/resizableContentWidget'; import * as dom from 'vs/base/browser/dom'; import { ConfigurationChangedEvent, EditorOption } from 'vs/editor/common/config/editorOptions'; import { Position } from 'vs/editor/common/core/position'; import { HoverStartSource } from 'vs/editor/contrib/hover/browser/hoverOperation'; import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; import { PositionAffinity } from 'vs/editor/common/model'; import { IEditorHoverColorPickerWidget } from 'vs/editor/contrib/hover/browser/hoverTypes'; const SCROLLBAR_WIDTH = 10; // TODO: maybe don't need the resizable widget class export class ResizableHoverWidget extends ResizableWidget { public ID = 'editor.contrib.resizableContentHoverWidget'; private hoverDisposables = new DisposableStore(); // The ContentWidget is a child of the resizable widget private resizableContentWidget: ResizableContentHoverWidget; public readonly allowEditorOverflow = true; public readonly _hover: HoverWidget = this.hoverDisposables.add(new HoverWidget()); private readonly editor: ICodeEditor; private readonly _hoverVisibleKey = EditorContextKeys.hoverVisible.bindTo(this._contextKeyService); private readonly _hoverFocusedKey = EditorContextKeys.hoverFocused.bindTo(this._contextKeyService); private readonly _focusTracker = this.hoverDisposables.add(dom.trackFocus(this.getDomNode())); private readonly _horizontalScrollingBy: number = 30; private _visibleData: ContentHoverVisibleData | null = null; private _renderingAbove: ContentWidgetPositionPreference; constructor( editor: ICodeEditor, @IContextKeyService private readonly _contextKeyService: IContextKeyService ) { super(editor, new MultipleSizePersistingOptions()); this.editor = editor; // create here the dom node and all other logic should go here that was in the super abstract class this.resizableContentWidget = new ResizableContentHoverWidget(this, editor); this._renderingAbove = this.editor.getOption(EditorOption.hover).above ? ContentWidgetPositionPreference.ABOVE : ContentWidgetPositionPreference.BELOW; this.hoverDisposables.add(this.element.onDidResize((e) => { // When the resizable hover overlay changes, resize the widget // this._widget.resize(e.dimension); })); this.hoverDisposables.add(this.editor.onDidLayoutChange(() => this._layout())); this.hoverDisposables.add(this.editor.onDidChangeConfiguration((e: ConfigurationChangedEvent) => { if (e.hasChanged(EditorOption.fontInfo)) { this._updateFont(); } })); this._setVisibleData(null); this._layout(); this.hoverDisposables.add(this._focusTracker.onDidFocus(() => { this._hoverFocusedKey.set(true); })); this.hoverDisposables.add(this._focusTracker.onDidBlur(() => { this._hoverFocusedKey.set(false); })); dom.append(this.element.domNode, this._hover.containerDomNode); } public get position(): Position | null { return this._visibleData?.showAtPosition ?? null; } public get isColorPickerVisible(): boolean { return Boolean(this._visibleData?.colorPicker); } public get isVisibleFromKeyboard(): boolean { return (this._visibleData?.source === HoverStartSource.Keyboard); } public get isVisible(): boolean { return this._hoverVisibleKey.get() ?? false; } public get renderingAbove(): ContentWidgetPositionPreference { return this._renderingAbove; } public set renderingAbove(renderingAbove: ContentWidgetPositionPreference) { this._renderingAbove = renderingAbove; } // NEW public override resize(size: dom.Dimension) { console.log('Inside of resize'); // Removing the max height and max width here - the max size is controlled by the resizable overlay this._hover.contentsDomNode.style.maxHeight = 'none'; this._hover.contentsDomNode.style.maxWidth = 'none'; const width = size.width + 'px'; // const width = size.width - 2 * SASH_WIDTH + TOTAL_BORDER_WIDTH + 'px'; this._hover.containerDomNode.style.width = width; this._hover.contentsDomNode.style.width = width; // const height = size.height - 2 * SASH_WIDTH + TOTAL_BORDER_WIDTH + 'px'; const height = size.height + 'px'; this._hover.containerDomNode.style.height = height; this._hover.contentsDomNode.style.height = height; const scrollDimensions = this._hover.scrollbar.getScrollDimensions(); const hasHorizontalScrollbar = (scrollDimensions.scrollWidth > scrollDimensions.width); if (hasHorizontalScrollbar) { // When there is a horizontal scroll-bar use a different height to make the scroll-bar visible const extraBottomPadding = `${this._hover.scrollbar.options.horizontalScrollbarSize}px`; if (this._hover.contentsDomNode.style.paddingBottom !== extraBottomPadding) { this._hover.contentsDomNode.style.paddingBottom = extraBottomPadding; } this._hover.contentsDomNode.style.height = size.height - SCROLLBAR_WIDTH + 'px'; // - 2 * SASH_WIDTH + TOTAL_BORDER_WIDTH } this._hover.scrollbar.scanDomNode(); this.editor.layoutContentWidget(this.resizableContentWidget); this.editor.render(); } public override findMaximumRenderingHeight(): number | undefined { if (!this.editor || !this.editor.hasModel() || !this._visibleData?.showAtPosition) { return; } const editorBox = dom.getDomNodePagePosition(this.editor.getDomNode()); const mouseBox = this.editor.getScrolledVisiblePosition(this._visibleData.showAtPosition); const bodyBox = dom.getClientArea(document.body); let availableSpace: number; if (this._renderingAbove === ContentWidgetPositionPreference.ABOVE) { availableSpace = editorBox.top + mouseBox.top - 30; } else { const mouseBottom = editorBox.top + mouseBox!.top + mouseBox!.height; availableSpace = bodyBox.height - mouseBottom; } let divMaxHeight = 0; for (const childHtmlElement of this._hover.contentsDomNode.children) { divMaxHeight += childHtmlElement.clientHeight; } if (this._hover.contentsDomNode.clientWidth < this._hover.contentsDomNode.scrollWidth) { divMaxHeight += SCROLLBAR_WIDTH; } return Math.min(availableSpace, divMaxHeight); } public findMaxRenderingWidth(): number | undefined { if (!this.editor || !this.editor.hasModel()) { return; } const editorBox = dom.getDomNodePagePosition(this.editor.getDomNode()); const widthOfEditor = editorBox.width; const leftOfEditor = editorBox.left; const glyphMarginWidth = this.editor.getLayoutInfo().glyphMarginWidth; const leftOfContainer = this._hover.containerDomNode.offsetLeft; return widthOfEditor + leftOfEditor - leftOfContainer - glyphMarginWidth; } public override dispose(): void { this.editor.removeContentWidget(this.resizableContentWidget); if (this._visibleData) { this._visibleData.disposables.dispose(); } super.dispose(); } public getDomNode() { return this._hover.containerDomNode; } public getContentsDomNode() { return this._hover.contentsDomNode; } public isMouseGettingCloser(posx: number, posy: number): boolean { if (!this._visibleData) { return false; } if (typeof this._visibleData.initialMousePosX === 'undefined' || typeof this._visibleData.initialMousePosY === 'undefined') { this._visibleData.initialMousePosX = posx; this._visibleData.initialMousePosY = posy; return false; } const widgetRect = dom.getDomNodePagePosition(this.resizableContentWidget.getDomNode()); if (typeof this._visibleData.closestMouseDistance === 'undefined') { this._visibleData.closestMouseDistance = computeDistanceFromPointToRectangle(this._visibleData.initialMousePosX, this._visibleData.initialMousePosY, widgetRect.left, widgetRect.top, widgetRect.width, widgetRect.height); } const distance = computeDistanceFromPointToRectangle(posx, posy, widgetRect.left, widgetRect.top, widgetRect.width, widgetRect.height); if (!distance || !this._visibleData.closestMouseDistance || distance > this._visibleData.closestMouseDistance + 4 /* tolerance of 4 pixels */) { // The mouse is getting farther away return false; } this._visibleData.closestMouseDistance = Math.min(this._visibleData.closestMouseDistance, distance); return true; } private _setVisibleData(visibleData: ContentHoverVisibleData | null): void { if (this._visibleData) { this._visibleData.disposables.dispose(); } this._visibleData = visibleData; this._hoverVisibleKey.set(!!this._visibleData); this._hover.containerDomNode.classList.toggle('hidden', !this._visibleData); } private _layout(): void { const height = Math.max(this.editor.getLayoutInfo().height / 4, 250); const { fontSize, lineHeight } = this.editor.getOption(EditorOption.fontInfo); this._hover.contentsDomNode.style.fontSize = `${fontSize}px`; this._hover.contentsDomNode.style.lineHeight = `${lineHeight / fontSize}`; this._hover.contentsDomNode.style.maxHeight = `${height}px`; this._hover.contentsDomNode.style.maxWidth = `${Math.max(this.editor.getLayoutInfo().width * 0.66, 500)}px`; } private _updateFont(): void { const codeClasses: HTMLElement[] = Array.prototype.slice.call(this._hover.contentsDomNode.getElementsByClassName('code')); codeClasses.forEach(node => this.editor.applyFontInfo(node)); } public showAt(node: DocumentFragment, visibleData: ContentHoverVisibleData): void { this.editor.addContentWidget(this.resizableContentWidget); const persistedSize = this.findPersistedSize(); if (!this.editor || !this.editor.hasModel()) { return; } this._setVisibleData(visibleData); this._hover.contentsDomNode.textContent = ''; this._hover.contentsDomNode.appendChild(node); this._hover.contentsDomNode.style.paddingBottom = ''; this._updateFont(); const containerDomNode = this.resizableContentWidget.getDomNode(); let height; // If the persisted size has already been found then set a maximum height and width if (!persistedSize) { this._hover.contentsDomNode.style.maxHeight = `${Math.max(this.editor.getLayoutInfo().height / 4, 250)}px`; this._hover.contentsDomNode.style.maxWidth = `${Math.max(this.editor.getLayoutInfo().width * 0.66, 500)}px`; this.onContentsChanged(); // Simply force a synchronous render on the editor // such that the widget does not really render with left = '0px' this.editor.render(); height = containerDomNode.clientHeight; } // When there is a persisted size then do not use a maximum height or width else { this._hover.contentsDomNode.style.maxHeight = 'none'; this._hover.contentsDomNode.style.maxWidth = 'none'; height = persistedSize.height; } // The dimensions of the document in which we are displaying the hover const bodyBox = dom.getClientArea(document.body); // Hard-coded in the hover.css file as 1.5em or 24px const minHeight = 24; // The full height is already passed in as a parameter const fullHeight = height; const editorBox = dom.getDomNodePagePosition(this.editor.getDomNode()); const mouseBox = this.editor.getScrolledVisiblePosition(visibleData.showAtPosition); // Position where the editor box starts + the top of the mouse box relatve to the editor + mouse box height const mouseBottom = editorBox.top + mouseBox.top + mouseBox.height; // Total height of the box minus the position of the bottom of the mouse, this is the maximum height below the mouse position const availableSpaceBelow = bodyBox.height - mouseBottom; // Max height below is the minimum of the available space below and the full height of the widget const maxHeightBelow = Math.min(availableSpaceBelow, fullHeight); // The available space above the mouse position is the height of the top of the editor plus the top of the mouse box relative to the editor const availableSpaceAbove = editorBox.top + mouseBox.top - 30; const maxHeightAbove = Math.min(availableSpaceAbove, fullHeight); // We find the maximum height of the widget possible on the top or on the bottom const maxHeight = Math.min(Math.max(maxHeightAbove, maxHeightBelow), fullHeight); if (height < minHeight) { height = minHeight; } if (height > maxHeight) { height = maxHeight; } // Determining whether we should render above or not ideally if (this.editor.getOption(EditorOption.hover).above) { this._renderingAbove = height <= maxHeightAbove ? ContentWidgetPositionPreference.ABOVE : ContentWidgetPositionPreference.BELOW; } else { this._renderingAbove = height <= maxHeightBelow ? ContentWidgetPositionPreference.BELOW : ContentWidgetPositionPreference.ABOVE; } // See https://github.com/microsoft/vscode/issues/140339 // TODO: Doing a second layout of the hover after force rendering the editor if (!persistedSize) { this.onContentsChanged(); } if (visibleData.stoleFocus) { this._hover.containerDomNode.focus(); } visibleData.colorPicker?.layout(); if (!this._visibleData) { return; } const clientHeight = this._hover.containerDomNode.clientHeight; const clientWidth = this._hover.containerDomNode.clientWidth; this.element.layout(clientHeight, clientWidth); this.resizableContentWidget.position = this._visibleData.showAtPosition; this.resizableContentWidget.secondaryPosition = this._visibleData.showAtSecondaryPosition; this.resizableContentWidget.preference = [this._renderingAbove]; this.resizableContentWidget.positionAffinity = this._visibleData.isBeforeContent ? PositionAffinity.LeftOfInjectedText : undefined; this.editor.layoutContentWidget(this.resizableContentWidget); this.editor.render(); console.log('At the end of showAt'); } public override hide(): void { this.element.clearSashHoverState(); if (this._visibleData) { const stoleFocus = this._visibleData.stoleFocus; this._setVisibleData(null); this.editor.layoutContentWidget(this.resizableContentWidget); if (stoleFocus) { this.editor.focus(); } } } // NEW public onContentsChanged(persistedSize?: dom.Dimension | undefined): void { console.log('Inside of onContentsChanged'); const containerDomNode = this.getDomNode(); const contentsDomNode = this.getContentsDomNode(); // Suppose a persisted size is defined if (persistedSize) { const widthMinusSash = Math.min(this.findMaximumRenderingWidth() ?? Infinity, persistedSize.width); //  - SASH_WIDTH // const heightMinusSash = Math.min(this.findMaxRenderingHeight(this._renderingAbove) ?? Infinity, persistedSize.height - SASH_WIDTH); const heightMinusSash = Math.min(this.findMaximumRenderingHeight() ?? Infinity, persistedSize.height); // SASH_WIDTH // Already setting directly the height and width parameters containerDomNode.style.width = widthMinusSash + 'px'; containerDomNode.style.height = heightMinusSash + 'px'; contentsDomNode.style.width = widthMinusSash + 'px'; contentsDomNode.style.height = heightMinusSash + 'px'; } else { // Otherwise the height and width are set to auto containerDomNode.style.width = 'auto'; containerDomNode.style.height = 'auto'; contentsDomNode.style.width = 'auto'; contentsDomNode.style.height = 'auto'; } this.editor.layoutContentWidget(this.resizableContentWidget); this._hover.onContentsChanged(); const scrollDimensions = this._hover.scrollbar.getScrollDimensions(); const hasHorizontalScrollbar = (scrollDimensions.scrollWidth > scrollDimensions.width); if (hasHorizontalScrollbar) { // There is just a horizontal scrollbar const extraBottomPadding = `${this._hover.scrollbar.options.horizontalScrollbarSize}px`; let reposition = false; if (this._hover.contentsDomNode.style.paddingBottom !== extraBottomPadding) { this._hover.contentsDomNode.style.paddingBottom = extraBottomPadding; reposition = true; } const maxRenderingHeight = this.findMaximumRenderingHeight(); // Need the following code since we are using an exact height when using the persisted size. If not used the horizontal scrollbar would just not be visible. if (persistedSize && maxRenderingHeight) { containerDomNode.style.height = Math.min(maxRenderingHeight, persistedSize.height) + 'px'; //  - SASH_WIDTH contentsDomNode.style.height = Math.min(maxRenderingHeight, persistedSize.height - SCROLLBAR_WIDTH) + 'px'; //  - SASH_WIDTH reposition = true; } if (reposition) { this.editor.layoutContentWidget(this.resizableContentWidget); this._hover.onContentsChanged(); } } } // OLD FUNCTION /* public onContentsChanged(): void { this.editor.layoutContentWidget(this.resizableContentWidget); this._hover.onContentsChanged(); const scrollDimensions = this._hover.scrollbar.getScrollDimensions(); const hasHorizontalScrollbar = (scrollDimensions.scrollWidth > scrollDimensions.width); if (hasHorizontalScrollbar) { // There is just a horizontal scrollbar const extraBottomPadding = `${this._hover.scrollbar.options.horizontalScrollbarSize}px`; if (this._hover.contentsDomNode.style.paddingBottom !== extraBottomPadding) { this._hover.contentsDomNode.style.paddingBottom = extraBottomPadding; this.editor.layoutContentWidget(this.resizableContentWidget); this._hover.onContentsChanged(); } } } */ public clear(): void { this._hover.contentsDomNode.textContent = ''; } public focus(): void { this._hover.containerDomNode.focus(); } public scrollUp(): void { const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop; const fontInfo = this.editor.getOption(EditorOption.fontInfo); this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop - fontInfo.lineHeight }); } public scrollDown(): void { const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop; const fontInfo = this.editor.getOption(EditorOption.fontInfo); this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop + fontInfo.lineHeight }); } public scrollLeft(): void { const scrollLeft = this._hover.scrollbar.getScrollPosition().scrollLeft; this._hover.scrollbar.setScrollPosition({ scrollLeft: scrollLeft - this._horizontalScrollingBy }); } public scrollRight(): void { const scrollLeft = this._hover.scrollbar.getScrollPosition().scrollLeft; this._hover.scrollbar.setScrollPosition({ scrollLeft: scrollLeft + this._horizontalScrollingBy }); } public pageUp(): void { const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop; const scrollHeight = this._hover.scrollbar.getScrollDimensions().height; this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop - scrollHeight }); } public pageDown(): void { const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop; const scrollHeight = this._hover.scrollbar.getScrollDimensions().height; this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop + scrollHeight }); } public goToTop(): void { this._hover.scrollbar.setScrollPosition({ scrollTop: 0 }); } public goToBottom(): void { this._hover.scrollbar.setScrollPosition({ scrollTop: this._hover.scrollbar.getScrollDimensions().scrollHeight }); } public escape(): void { this.editor.focus(); } } export class ResizableContentHoverWidget extends ResizableContentWidget { public ID = 'editor.contrib.resizableContentHoverWidget'; private hoverDisposables = new DisposableStore(); constructor(resizableHoverWidget: ResizableHoverWidget, editor: ICodeEditor) { super(resizableHoverWidget, editor); console.log('Inside of resizable content hover widget'); } } class ContentHoverVisibleData { public closestMouseDistance: number | undefined = undefined; constructor( public readonly colorPicker: IEditorHoverColorPickerWidget | null, public readonly showAtPosition: Position, public readonly showAtSecondaryPosition: Position, public readonly preferAbove: boolean, public readonly stoleFocus: boolean, public readonly source: HoverStartSource, public readonly isBeforeContent: boolean, public initialMousePosX: number | undefined, public initialMousePosY: number | undefined, public readonly disposables: DisposableStore ) { } } function computeDistanceFromPointToRectangle(pointX: number, pointY: number, left: number, top: number, width: number, height: number): number { const x = (left + width / 2); // x center of rectangle const y = (top + height / 2); // y center of rectangle const dx = Math.max(Math.abs(pointX - x) - width / 2, 0); const dy = Math.max(Math.abs(pointY - y) - height / 2, 0); return Math.sqrt(dx * dx + dy * dy); } </ins>


write(editSession: EditSession): Promise<string>; delete(ref: string | null): Promise<void>; list(): Promise<IResourceRefHandle[]>; <ins> getMachineById(machineId: string): Promise<string | undefined>; </ins> } export const IEditSessionsLogService = createDecorator<IEditSessionsLogService>('IEditSessionsLogService');


integrity sha512-ua7PgUoeQFjmWPcoo9khiPum3Pd60k4/2ZGXt18sm2Slk0W0xZTqt5Y0Ny1NyBiN1EVQ/+FaF9NcY4Qe6rwk5w== "@vscode/emmet-helper@^2.3.0": <del> version "2.8.4" resolved "https://registry.yarnpkg.com/@vscode/emmet-helper/-/emmet-helper-2.8.4.tgz#ab937e3ce79b0873c604d1ad50a9eeb7abae2937" integrity sha512-lUki5QLS47bz/U8IlG9VQ+1lfxMtxMZENmU5nu4Z71eOD5j9FK0SmYGL5NiVJg9WBWeAU0VxRADMY2Qpq7BfVg== </del> <ins> version "2.8.6" resolved "https://registry.yarnpkg.com/@vscode/emmet-helper/-/emmet-helper-2.8.6.tgz#ee2fa52321d6af8a40310fd9d37b8590a4dabb18" integrity sha512-IIB8jbiKy37zN8bAIHx59YmnIelY78CGHtThnibD/d3tQOKRY83bYVi9blwmZVUZh6l9nfkYH3tvReaiNxY9EQ== </ins> dependencies: emmet "^2.3.0" jsonc-parser "^2.3.0" vscode-languageserver-textdocument "^1.0.1" vscode-languageserver-types "^3.15.1" <del> vscode-nls "^5.0.0" </del> vscode-uri "^2.1.2" emmet@^2.3.0:


required: ['include'] } ], <ins> minItems: 2, maxItems: 2, </ins> additionalItems: false, examples: [ ['search', { 'include': ['${workspaceFolder}'] }],


{ ...state.shellLaunchConfig, cwd: state.processDetails.cwd, <ins> color: state.processDetails.color, icon: state.processDetails.icon, name: state.processDetails.title, </ins> initialText: state.replayEvent.events[0].data + 'x1b[0mnnrx1b[1;48;5;252;38;5;234m ' + restoreMessage + ' x1b[Kx1b[0mnr' }, state.processDetails.cwd,


} } <del> class SelectionToReplAction extends EditorAction { </del> <ins> export class SelectionToReplAction extends EditorAction { public static readonly ID = 'editor.debug.action.selectionToRepl'; public static readonly LABEL = nls.localize('evaluateInDebugConsole', "Evaluate in Debug Console"); </ins> constructor() { super({ <del> id: 'editor.debug.action.selectionToRepl', label: nls.localize('evaluateInDebugConsole', "Evaluate in Debug Console"), alias: 'Evaluate', </del> <ins> id: SelectionToReplAction.ID, label: SelectionToReplAction.LABEL, alias: 'Debug: Evaluate in Console', </ins> precondition: ContextKeyExpr.and(EditorContextKeys.hasNonEmptySelection, CONTEXT_IN_DEBUG_MODE, EditorContextKeys.editorTextFocus), contextMenuOpts: { group: 'debug',


overviewRulerLanes, parameterHints, peekWidgetDefaultFocus, <ins> definitionLinkOpensInPeek, </ins> quickSuggestions, quickSuggestionsDelay, readOnly,


// Remove Element from Parent (Model) const parent = modelElement.parent; parent.removeChild(modelElement); <ins> this.view?.focusNext(); </ins> const oldNestedParent = modelElement.nestedParent; if (oldNestedParent) {


*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> import * as dom from 'vs/base/browser/dom'; </del> import * as languages from 'vs/editor/common/languages'; import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';


registerDebugCommandPaletteItem(JUMP_TO_CURSOR_ID, nls.localize('jumpToCursor', "Jump to Cursor"), CONTEXT_JUMP_TO_CURSOR_SUPPORTED); registerDebugCommandPaletteItem(JUMP_TO_CURSOR_ID, nls.localize('SetNextStatement', "Set Next Statement"), CONTEXT_JUMP_TO_CURSOR_SUPPORTED); registerDebugCommandPaletteItem(RunToCursorAction.ID, RunToCursorAction.LABEL, ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_STATE.isEqualTo('stopped'))); <ins> registerDebugCommandPaletteItem(SelectionToReplAction.ID, SelectionToReplAction.LABEL, ContextKeyExpr.and(EditorContextKeys.hasNonEmptySelection, CONTEXT_IN_DEBUG_MODE)); registerDebugCommandPaletteItem(SelectionToWatchExpressionsAction.ID, SelectionToWatchExpressionsAction.LABEL, ContextKeyExpr.and(EditorContextKeys.hasNonEmptySelection, CONTEXT_IN_DEBUG_MODE)); </ins> registerDebugCommandPaletteItem(TOGGLE_INLINE_BREAKPOINT_ID, nls.localize('inlineBreakpoint', "Inline Breakpoint")); registerDebugCommandPaletteItem(DEBUG_START_COMMAND_ID, DEBUG_START_LABEL, ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, CONTEXT_DEBUG_STATE.notEqualsTo(getStateLabel(State.Initializing)))); registerDebugCommandPaletteItem(DEBUG_RUN_COMMAND_ID, DEBUG_RUN_LABEL, ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, CONTEXT_DEBUG_STATE.notEqualsTo(getStateLabel(State.Initializing))));


<del> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><style>.st0{opacity:0}.st0,.st1{fill:#2d2d30}.st2{fill:#c5c5c5}.st3{fill:#2b282e}</style><g id="outline"><path class="st0" d="M0 0h16v16H0z"/><path class="st1" d="M5 1v5H0v9h11v-2.586l1 1 4-4V1H5zm5 3v2L8 4.586V4h2zm-2 8H3V9h5v3z"/></g><g id="icon_x5F_bg"><path class="st2" d="M3 9h2v2H3zM6 10h2v2H6zM14 3v3h.586L15 5.586V2H6v4h1V3z"/><path class="st2" d="M9 10.414V13H2V8h6V7H1v7h9V11.414zM9.414 6H10V4H8v.586z"/><path class="st2" d="M13 5h-2v4L9 7v2l3 3 3-3V7l-2 2z"/></g><g id="icon_x5F_fg"><path class="st3" d="M8 9.414V8H2v5h7v-2.586l-1-1zM5 11H3V9h2v2zm3 1H6v-2h2v2zM8 4.586V4h6V3H7v3h1z"/></g></svg> </del>  No newline at end of file <ins> <svg fill="none" height="16" viewBox="0 0 16 16" width="16" xmlns="http://www.w3.org/2000/svg"><path d="m5 1v5h-5v9h11v-2.586l1 1 4-4v-8.414zm5 3v2l-2-1.414v-.586zm-2 8h-5v-3h5z" fill="#2d2d30"/><g fill="#c5c5c5"><path d="m3 9h2v2h-2zm3 1h2v2h-2zm8-7v3h.586l.414-.414v-3.586h-9v4h1v-3z"/><path d="m9 10.414v2.586h-7v-5h6v-1h-7v7h9v-2.586zm.414-4.414h.586v-2h-2v.586z"/><path d="m13 5h-2v4l-2-2v2l3 3 3-3v-2l-2 2z"/></g><path d="m8 9.414v-1.414h-6v5h7v-2.586zm-3 1.586h-2v-2h2zm3 1h-2v-2h2zm0-7.414v-.586h6v-1h-7v3h1z" fill="#2b282e"/></svg> </ins>  No newline at end of file


static readonly MenubarWindowMenu = new MenuId(); static readonly MenubarPreferencesMenu = new MenuId(); static readonly MenubarHelpMenu = new MenuId(); <del> static readonly MenubarTerminalMenu = new MenuId(); </del> readonly id: string = String(MenuId.ID++); }


this.toDisposeOnSessionEnd.get(session.getId()).push(session.onDidThread(event => { if (event.body.reason === 'started') { <del> this.fetchThreads(session).done(undefined, errors.onUnexpectedError); </del> <ins> // debounce to reduce threadsRequest frequency and improve performance let scheduler = this.fetchThreadsSchedulers.get(session.getId()); if (!scheduler) { scheduler = new RunOnceScheduler(() => { this.fetchThreads(session).done(undefined, errors.onUnexpectedError); }, 100); this.fetchThreadsSchedulers.set(session.getId(), scheduler); this.toDisposeOnSessionEnd.get(session.getId()).push(scheduler); } if (!scheduler.isScheduled()) { scheduler.schedule(); } </ins> } else if (event.body.reason === 'exited') { this.model.clearThreads(session.getId(), true, event.body.threadId); }


stickiness: TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges, afterContentClassName: 'inline-folded', className: 'folded-background', <ins> minimap: foldedBackgroundMinimap, </ins> isWholeLine: true, firstLineDecorationClassName: ThemeIcon.asClassName(foldingCollapsedIcon) });


const primary: IAction[] = []; const secondary: IAction[] = []; <del> let onDidChange = Event.None; </del> <ins> let onDidChange; </ins> // Editor actions require the editor control to be there, so we retrieve it via service const activeEditorPane = this.activeEditorPane;


this.domNode = document.createElement('div'); this.domNode.className = `monaco-tree no-focused-item monaco-tree-instance-${this.instance}`; <del> this.domNode.tabIndex = 0; </del> <ins> // to allow direct tabbing into the tree instead of first focusing the tree this.domNode.tabIndex = context.options.preventRootFocus ? -1 : 0; </ins> this.styleElement = DOM.createStyleSheet(this.domNode);


this.toUnbind.push(this.onDidPanelClose(panel => this.compositeBar.deactivateComposite(panel.getId()))); } <ins> private _onDidPanelOpen(viewlet: IPanel): void { this.activePanelContextKey.set(viewlet.getId()); } private _onDidPanelClose(viewlet: IPanel): void { const id = viewlet.getId(); if (this.activePanelContextKey.get() === id) { this.activePanelContextKey.set(''); } } </ins> public get onDidPanelOpen(): Event<IPanel> { return this._onDidCompositeOpen.event; }


this._register(this.model.onDidChange(() => { this.updateContextKeys(); })); <ins> this._register(this.editor.onDidChangeModelContent(() => { this.contextKeys.inlineSuggestionJustCommitted.reset(); })); this._register(this.editor.onDidChangeCursorPosition(() => { this.contextKeys.inlineSuggestionJustCommitted.reset(); })); </ins> this.updateContextKeys(); }


} } linkCandidates.push(...specialEndLinkCandidates); <ins> this._logService.trace('terminalLocaLinkDetector#detect linkCandidates', linkCandidates); </ins> // Validate the path and convert to the outgoing type const simpleLink = await this._validateAndGetLink(undefined, bufferRange, linkCandidates, trimRangeMap);


DOM.removeClass(image, 'scale-to-fit'); image.style.minWidth = `${(image.naturalWidth * scale)}px`; <del> image.style.widows = `${(image.naturalWidth * scale)}px`; </del> <ins> image.style.width = `${(image.naturalWidth * scale)}px`; </ins> const newWidth = image.width; const scaleFactor = (newWidth - oldWidth) / oldWidth;


export function startsWithUTF8BOM(str: string): boolean { return (str && str.length > 0 && str.charCodeAt(0) === __utf8_bom); <del> } </del>  No newline at end of file <ins> } </ins>


import { Extensions, IConfigurationRegistry } from 'vs/platform/configuration/common/configurationRegistry'; import { IQuickInputService, IQuickPickItem } from 'vs/platform/quickinput/common/quickInput'; import { ExtensionsRegistry } from 'vs/workbench/services/extensions/common/extensionsRegistry'; <del> import { ContextKeyExpr, ContextKeyExpression, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; </del> <ins> import { ContextKeyExpr, ContextKeyExpression, IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; </ins> import { ICommandService } from 'vs/platform/commands/common/commands'; import { getVirtualWorkspaceLocation } from 'vs/platform/workspace/common/virtualWorkspace'; import { Schemas } from 'vs/base/common/network'; import { IsWebContext } from 'vs/platform/contextkey/common/contextkeys'; import { isProposedApiEnabled } from 'vs/workbench/services/extensions/common/extensions'; import { EditSessionsLogService } from 'vs/workbench/contrib/editSessions/common/editSessionsLogService'; <del> import { IViewContainersRegistry, Extensions as ViewExtensions, ViewContainerLocation } from 'vs/workbench/common/views'; </del> <ins> import { IViewContainersRegistry, Extensions as ViewExtensions, ViewContainerLocation, IViewsService } from 'vs/workbench/common/views'; </ins> import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors'; import { ViewPaneContainer } from 'vs/workbench/browser/parts/views/viewPaneContainer'; import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';


.search-view > .results > .monaco-tree .monaco-tree-row.focused .content .filematch .monaco-count-badge, .search-view > .results > .monaco-tree .monaco-tree-row.focused .content .foldermatch .monaco-count-badge, .search-view > .results > .monaco-tree .monaco-tree-row.focused .content .linematch .monaco-count-badge { <del> display: none; </del> <ins> margin-right: 0; </ins> } .search-view .focused .monaco-tree-row.selected:not(.highlighted) > .content.actions .action-remove,


private async doSearch(fqs: IFolderQuery<URI>[], onResult: (match: IInternalFileMatch) => void): Promise<IFileSearchProviderStats | null> { const cancellation = new CancellationTokenSource(); const folderOptions = fqs.map(fq => this.getSearchOptionsForFolder(fq)); <ins> const session = this.provider instanceof OldFileSearchProviderConverter ? this.sessionLifecycle?.tokenSource.token : this.sessionLifecycle?.obj; </ins> const options: FileSearchProviderOptions = { folderOptions, maxResults: this.config.maxResults ?? DEFAULT_MAX_SEARCH_RESULTS, <del> session: this.sessionToken </del> <ins> session </ins> };


private open(id: string, extension: IExtension, template: IExtensionEditorTemplate): Promise<IActiveElement | null> { switch (id) { case NavbarSection.Readme: return this.openReadme(template); <del> case NavbarSection.Contributions: return this.openContributions(template); </del> <ins> case NavbarSection.FeatureContributions: return this.openContributions(template); </ins> case NavbarSection.Changelog: return this.openChangelog(template); case NavbarSection.Dependencies: return this.openDependencies(extension, template); case NavbarSection.ExtensionPack: return this.openExtensionPack(extension, template);


return undefined; } get cwd(): string | undefined { return this._cwd; } <ins> private get _isInputting(): boolean { return !!(this._currentCommand.commandStartMarker && !this._currentCommand.commandExecutedMarker); } get hasInput(): boolean | undefined { if (!this._isInputting || !this._currentCommand?.commandStartMarker) { return undefined; } if (this._terminal.buffer.active.baseY + this._terminal.buffer.active.cursorY === this._currentCommand.commandStartMarker?.line) { const line = this._terminal.buffer.active.getLine(this._terminal.buffer.active.cursorY)?.translateToString(true, this._currentCommand.commandStartX); if (line === undefined) { return undefined; } return line.length > 0; } return true; } </ins> private readonly _onCommandStarted = new Emitter<ITerminalCommand>(); readonly onCommandStarted = this._onCommandStarted.event;


} protected restoreViewState(input: EditorInput) { <del> if (input instanceof UntitledEditorInput) { </del> <ins> if (input instanceof UntitledEditorInput || input instanceof ResourceEditorInput) { </ins> const viewState = this.loadTextEditorViewState(input.getResource().toString()); if (viewState) { this.getControl().restoreViewState(viewState);


<del> <svg xmlns="http://www.w3.org/2000/svg" width="15" height="21" x="0px" y="0px" viewBox="0 0 15 21" style="enable-background:new 0 0 15 21;"><polygon style="fill:#FFFFFF;stroke:#000000" points="14.5,1.2 1.9,13.8 7.1,13.8 4.5,19.1 7.7,20.1 10.3,14.9 14.5,18"/></svg> </del>  No newline at end of file <ins> <svg xmlns="http://www.w3.org/2000/svg" width="15" height="25" x="0px" y="0px" viewBox="0 0 15 25" style="enable-background:new 0 0 15 25;"><polygon style="fill:#FFFFFF;stroke:#000000" points="14.5,1.2 1.9,13.8 7,13.8 3.2,21.5 6.3,22.5 10.1,14.9 14.5,18"/></svg> </ins>  No newline at end of file


import { WebviewResourceProvider } from './util/resources'; import { isOfScheme, Schemes } from './util/schemes'; <del> const UNICODE_NEWLINE_REGEX = /u2028|u2029/g; </del> /** * Adds begin line index to the output via the 'data-line' data attribute. */


} .quick-input-widget .interactive-session .interactive-input-part .interactive-execute-toolbar { <del> bottom: 1px; </del> <ins> margin-bottom: 1px; </ins> } .quick-input-widget .interactive-session .interactive-input-and-execute-toolbar {


builtin printf "e]633;P;ContinuationPrompt=$(echo "$PS2" | sed 's/x1b/x1b/g')a" __vsc_report_prompt() { <ins> # HACK: Git bash is too slow at reporting the prompt, so skip for now if [ "$__vsc_is_windows" = "1" ]; then return fi </ins> # Expand the original PS1 similarly to how bash would normally # See https://stackoverflow.com/a/37137981 for technique if ((BASH_VERSINFO[0] >= 5 || (BASH_VERSINFO[0] == 4 && BASH_VERSINFO[1] >= 4))); then


const keybindingsExtPoint = ExtensionsRegistry.registerExtensionPoint<ContributedKeyBinding | ContributedKeyBinding[]>({ extensionPoint: 'keybindings', <ins> deps: [commandsExtensionPoint], </ins> jsonSchema: { description: nls.localize('vscode.extension.contributes.keybindings', "Contributes keybindings."), oneOf: [


} const index = this.mustGetTaskIndex(taskId); <ins> const oldTerminalStatePrio = terminalStatePriorities[entry.tasks[index].state]; const newTerminalStatePrio = terminalStatePriorities[state]; // Ignore requests to set the state from one terminal state back to a // "lower" one, e.g. from failed back to passed: if (oldTerminalStatePrio !== undefined && (newTerminalStatePrio === undefined || newTerminalStatePrio < oldTerminalStatePrio)) { return; } </ins> this.fireUpdateAndRefresh(entry, index, state, duration); }


if (this.widget.viewModel) { this.chatService.clearSession(this.widget.viewModel.sessionId); } <ins> this.viewState.inputValue = ''; </ins> this.updateModel(); }


return; } <ins> if (e.browserEvent.defaultPrevented) { return; } </ins> super.onDoubleClick(e); } }


} this._currentCommand.commandFinishedMarker = this._terminal.registerMarker(0); <del> const command = this._currentCommand.command; </del> <ins> let command = this._currentCommand.command; </ins> this._logService.debug('CommandDetectionCapability#handleCommandFinished', this._terminal.buffer.active.cursorX, this._currentCommand.commandFinishedMarker?.line, this._currentCommand.command, this._currentCommand); this._exitCode = exitCode;


registerEditorCommand(new CursorWordStartRightSelect()); registerEditorCommand(new CursorWordEndRightSelect()); registerEditorCommand(new CursorWordRightSelect()); <ins> registerEditorCommand(new CursorWordAccessibilityLeft()); registerEditorCommand(new CursorWordAccessibilityLeftSelect()); registerEditorCommand(new CursorWordAccessibilityRight()); registerEditorCommand(new CursorWordAccessibilityRightSelect()); </ins> registerEditorCommand(new DeleteWordStartLeft()); registerEditorCommand(new DeleteWordEndLeft()); registerEditorCommand(new DeleteWordLeft());


return true; } <del> const domain = `${url.scheme}://${url.authority}`; </del> for (let i = 0; i < trustedDomains.length; i++) { if (trustedDomains[i] === '*') { return true; } <del> if (trustedDomains[i] === domain) { </del> <ins> if (isTrusted(url.toString(), trustedDomains[i])) { </ins> return true; } <ins> } </ins> <del> let parsedTrustedDomain; if (/^https?:///.test(trustedDomains[i])) { parsedTrustedDomain = URI.parse(trustedDomains[i]); if (url.scheme !== parsedTrustedDomain.scheme) { continue; } } else { parsedTrustedDomain = URI.parse('https://' + trustedDomains[i]); } </del> <ins> return false; } </ins> <del> if (url.authority === parsedTrustedDomain.authority) { if (pathMatches(url.path, parsedTrustedDomain.path)) { return true; } else { continue; } } </del> <ins> export const isTrusted = (url: string, trustedURL: string): boolean => { const normalize = (url: string) => url.replace(//+$/, ''); trustedURL = normalize(trustedURL); url = normalize(url); </ins> <del> if (trustedDomains[i].indexOf('*') !== -1) { </del> <ins> const memo = Array.from({ length: url.length + 1 }).map(() => Array.from({ length: trustedURL.length + 1 }).map(() => undefined), ); </ins> <del> let reversedAuthoritySegments = url.authority.split('.').reverse(); const reversedTrustedDomainAuthoritySegments = parsedTrustedDomain.authority.split('.').reverse(); </del> <ins> if (/^[^./:]*:///.test(trustedURL)) { return doURLMatch(memo, url, trustedURL, 0, 0); } </ins> <del> if ( reversedTrustedDomainAuthoritySegments.length < reversedAuthoritySegments.length && reversedTrustedDomainAuthoritySegments[reversedTrustedDomainAuthoritySegments.length - 1] === '*' ) { reversedAuthoritySegments = reversedAuthoritySegments.slice(0, reversedTrustedDomainAuthoritySegments.length); } </del> <ins> const scheme = /^(https?):///.exec(url)?.[1]; if (scheme) { return doURLMatch(memo, url, `${scheme}://${trustedURL}`, 0, 0); } </ins> <del> const authorityMatches = reversedAuthoritySegments.every((val, i) => { return reversedTrustedDomainAuthoritySegments[i] === '*' || val === reversedTrustedDomainAuthoritySegments[i]; }); </del> <ins> return false; }; </ins> <del> if (authorityMatches && pathMatches(url.path, parsedTrustedDomain.path)) { return true; } } </del> <ins> const doURLMatch = ( memo: (boolean | undefined)[][], url: string, trustedURL: string, urlOffset: number, trustedURLOffset: number, ): boolean => { if (memo[urlOffset]?.[trustedURLOffset] !== undefined) { return memo[urlOffset][trustedURLOffset]!; </ins> } <del> return false; } </del> <ins> const options = []; </ins> <del> function pathMatches(open: string, rule: string) { if (rule === '/') { return true; </del> <ins> // Endgame. // Fully exact match if (urlOffset === url.length) { return trustedURLOffset === trustedURL.length; </ins> } <del> if (rule[rule.length - 1] === '/') { rule = rule.slice(0, -1); </del> <ins> // Some path remaining in url if (trustedURLOffset === trustedURL.length) { const remaining = url.slice(urlOffset); return remaining[0] === '/'; </ins> } <del> const openSegments = open.split('/'); const ruleSegments = rule.split('/'); for (let i = 0; i < ruleSegments.length; i++) { if (ruleSegments[i] !== openSegments[i]) { return false; </del> <ins> if (url[urlOffset] === trustedURL[trustedURLOffset]) { // Exact match. options.push(doURLMatch(memo, url, trustedURL, urlOffset + 1, trustedURLOffset + 1)); } if (trustedURL[trustedURLOffset] + trustedURL[trustedURLOffset + 1] === '*.') { // Any subdomain match. Either consume one thing that's not a / or : and don't advance base or consume nothing and do. if (!['/', ':'].includes(url[urlOffset])) { options.push(doURLMatch(memo, url, trustedURL, urlOffset + 1, trustedURLOffset)); </ins> } <ins> options.push(doURLMatch(memo, url, trustedURL, urlOffset, trustedURLOffset + 2)); </ins> } <del> return true; } </del> <ins> if (trustedURL[trustedURLOffset] + trustedURL[trustedURLOffset + 1] === '.*' && url[urlOffset] === '.') { // IP mode. Consume one segment of numbers or nothing. let endBlockIndex = urlOffset + 1; do { endBlockIndex++; } while (/[0-9]/.test(url[endBlockIndex])); if (['.', ':', '/', undefined].includes(url[endBlockIndex])) { options.push(doURLMatch(memo, url, trustedURL, endBlockIndex, trustedURLOffset + 2)); } } if (trustedURL[trustedURLOffset] + trustedURL[trustedURLOffset + 1] === ':*') { // any port match. Consume a port if it exists otherwise nothing. Always comsume the base. if (url[urlOffset] === ':') { let endPortIndex = urlOffset + 1; do { endPortIndex++; } while (/[0-9]/.test(url[endPortIndex])); options.push(doURLMatch(memo, url, trustedURL, endPortIndex, trustedURLOffset + 2)); } else { options.push(doURLMatch(memo, url, trustedURL, urlOffset, trustedURLOffset + 2)); } } return (memo[urlOffset][trustedURLOffset] = options.some(a => a === true)); }; </ins>


const minimapOpts = options.get(EditorOption.minimap); const minimapEnabled = minimapOpts.enabled; const minimapSide = minimapOpts.side; <del> const backgroundColor = minimapEnabled ? theme.getColor(editorOverviewRulerBackground) || TokenizationRegistry.getDefaultBackground() : null; </del> <ins> const themeColor = theme.getColor(editorOverviewRulerBackground); const defaultBackground = TokenizationRegistry.getDefaultBackground(); let backgroundColor: Color | null = null; if (themeColor !== undefined) { backgroundColor = themeColor; } else if (minimapEnabled) { backgroundColor = defaultBackground; } </ins> if (backgroundColor === null || minimapSide === 'left') { this.backgroundColor = null;


renderedWordCount: wordCountResult.actualWordCount, lastRenderTime: Date.now(), isFullyRendered: wordCountResult.isFullString, <ins> originalMarkdown: part.content, </ins> }; wordCountResults[index] = wordCountResult; }


return this.openerService.open(uri, { openToSide }); }, err => { <ins> const messageOrError = err instanceof Error ? (<Error>err).message : err; </ins> // different error cases <del> if (err === 'invalid') { </del> <ins> if (messageOrError === 'invalid') { </ins> this.notificationService.warn(nls.localize('invalid.url', 'Failed to open this link because it is not well-formed: {0}', link.url!.toString())); <del> } else if (err === 'missing') { </del> <ins> } else if (messageOrError === 'missing') { </ins> this.notificationService.warn(nls.localize('missing.url', 'Failed to open this link because its target is missing.')); } else { onUnexpectedError(err);


assert.strictEqual(result, 'test_2'); }); <ins> test('Increment file name with suffix version, too big number', function () { const name = 'test.9007199254740992.js'; const result = incrementFileName(name, false); assert.strictEqual(result, 'test.9007199254740992.1.js'); }); test('Increment folder name with suffix version, too big number', function () { const name = 'test.9007199254740992'; const result = incrementFileName(name, true); assert.strictEqual(result, 'test.9007199254740992.1'); }); </ins> test('Increment file name with prefix version', function () { const name = '1.test.js'; const result = incrementFileName(name, false);


import { ActiveEditorGroupLockedContext, ActiveEditorDirtyContext, EditorGroupEditorsCountContext, ActiveEditorStickyContext, ActiveEditorPinnedContext, ActiveEditorLastInGroupContext, ActiveEditorFirstInGroupContext, EditorPinnedAndUnpinnedTabsContext, ResourceContextKey, applyAvailableEditorIds, ActiveEditorAvailableEditorIdsContext, ActiveEditorCanSplitInGroupContext, SideBySideEditorActiveContext } from 'vs/workbench/common/contextkeys'; import { EditorInput } from 'vs/workbench/common/editor/editorInput'; import { SideBySideEditorInput } from 'vs/workbench/common/editor/sideBySideEditorInput'; <del> import { Emitter, Relay, Event } from 'vs/base/common/event'; </del> <ins> import { Emitter, Relay } from 'vs/base/common/event'; </ins> import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; import { Dimension, trackFocus, addDisposableListener, EventType, EventHelper, findParentWithClass, isAncestor, IDomNodePagePosition, isMouseEvent, isActiveElement, focusWindow } from 'vs/base/browser/dom'; import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';


private _isNext: boolean; <del> constructor(next: boolean, opts: IActionOptions) { </del> <ins> private _multiFile: boolean; constructor(next: boolean, multiFile: boolean, opts: IActionOptions) { </ins> super(opts); this._isNext = next; <ins> this._multiFile = multiFile; </ins> } public run(accessor: ServicesAccessor, editor: ICodeEditor): TPromise<void> {


import * as nls from 'vs/nls'; import { ContextKeyExpr, IContextKeyService, RawContextKey } from 'vs/platform/contextkey/common/contextkey'; import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; <ins> import { KeybindingsRegistry } from 'vs/platform/keybinding/common/keybindingsRegistry'; </ins> export class GhostTextController extends Disposable { public static readonly inlineSuggestionVisible = new RawContextKey<boolean>('inlineSuggestionVisible', false, nls.localize('inlineSuggestionVisible', "Whether an inline suggestion is visible")); public static readonly inlineSuggestionHasIndentation = new RawContextKey<boolean>('inlineSuggestionHasIndentation', false, nls.localize('inlineSuggestionHasIndentation', "Whether the inline suggestion starts with whitespace")); public static readonly inlineSuggestionHasIndentationLessThanTabSize = new RawContextKey<boolean>('inlineSuggestionHasIndentationLessThanTabSize', true, nls.localize('inlineSuggestionHasIndentationLessThanTabSize', "Whether the inline suggestion starts with whitespace that is less than what would be inserted by tab")); <ins> /** * Enables to use Ctrl+Left to undo fully (partially) accepted inline completions (the completion is no longer visible then). */ public static readonly inlineSuggestionJustCommitted = new RawContextKey<boolean>('inlineSuggestionJustCommitted', false, nls.localize('inlineSuggestionJustCommitted', "Whether an inline suggestion just got committed")); </ins> static ID = 'editor.contrib.ghostTextController';


resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8= <del> xterm-addon-search@0.9.0-beta.39: version "0.9.0-beta.39" resolved "https://registry.yarnpkg.com/xterm-addon-search/-/xterm-addon-search-0.9.0-beta.39.tgz#e8376e1485ee7d763c07d1a8f1354114f65b3e3e" integrity sha512-h45wkecgfqXXoAUqgNytAfSd6g0xNT6rZy/enVaEU0aes7QoL9pxHUKkCry8PP6hs03Slk0VxQ4AGsbSZGvK/w== </del> <ins> xterm-addon-search@0.9.0-beta.41: version "0.9.0-beta.41" resolved "https://registry.yarnpkg.com/xterm-addon-search/-/xterm-addon-search-0.9.0-beta.41.tgz#0992da36fe01ff6d71449265a9dabeef7f9d0a3f" integrity sha512-b1vuWR5JZ8QIiObbKkwSzpzf4x0B9hdzGCHJG+PXWT/xbxk65DOe/X9rgrRyOnCWe5ylQGG4DIHTiREigTp0lg== </ins> <del> xterm-addon-serialize@0.7.0-beta.13: version "0.7.0-beta.13" resolved "https://registry.yarnpkg.com/xterm-addon-serialize/-/xterm-addon-serialize-0.7.0-beta.13.tgz#5c859c8657cab7f28405aab1a0715daf54bc7714" integrity sha512-TYFlm/gds0pOmpzXw7ZWx8Cy48lMaOZZqZgfm5pWU37HPvzfKxXSVdYL1biWpRCH2zCH+3cWmOma8W1pBRr+Eg== </del> <ins> xterm-addon-serialize@0.7.0-beta.15: version "0.7.0-beta.15" resolved "https://registry.yarnpkg.com/xterm-addon-serialize/-/xterm-addon-serialize-0.7.0-beta.15.tgz#0f7d5f9b423802ac67c2a891d74de530a4fe6a65" integrity sha512-gO/dxqGgOAuj7DN2ETTeCHyalkb655XogZh5408CmH5D6mjI1lxqVLGUdiFeBVU/OHfWZT2PZ95k06VXqLU5kA== </ins> xterm-addon-unicode11@0.4.0-beta.3: version "0.4.0-beta.3" resolved "https://registry.yarnpkg.com/xterm-addon-unicode11/-/xterm-addon-unicode11-0.4.0-beta.3.tgz#f350184155fafd5ad0d6fbf31d13e6ca7dea1efa" integrity sha512-FryZAVwbUjKTmwXnm1trch/2XO60F5JsDvOkZhzobV1hm10sFLVuZpFyHXiUx7TFeeFsvNP+S77LAtWoeT5z+Q== <del> xterm-addon-webgl@0.12.0-beta.41: version "0.12.0-beta.41" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.12.0-beta.41.tgz#17dbca975b6e9b34526ebc57f4de59ee295da1b6" integrity sha512-wvQxC5diMYEJEMaILfz+4CWB2GgtzjzNQRNDnK7R7Y9wDI+P4idDlQKgyH0nA93sl9R4zgqlBVha//wuq4vfZg== </del> <ins> xterm-addon-webgl@0.12.0-beta.43: version "0.12.0-beta.43" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.12.0-beta.43.tgz#916ed4e390371403aab0d277097cd8a61be436e8" integrity sha512-hGXfwT6TOmp0tBDiS/iF8s0SLHLd3shJ5zQyS4HNtq99B5cEhHhwaUAZAfjLt5rnUt0kvqR9YWtGsDux5dWVLA== </ins> <del> xterm-headless@4.19.0-beta.60: version "4.19.0-beta.60" resolved "https://registry.yarnpkg.com/xterm-headless/-/xterm-headless-4.19.0-beta.60.tgz#ccd09a7c69ba487d3fd87d6a8d159f1a6a10e9b2" integrity sha512-mJ24BRnEDCASJDTGFZysZxiXkCmed3eMFiWCPvIF48LVrqxt1cImoVKBlxqkdgUkHKjfF2c92S1TTBL5aT1I0w== </del> <ins> xterm-headless@4.19.0-beta.67: version "4.19.0-beta.67" resolved "https://registry.yarnpkg.com/xterm-headless/-/xterm-headless-4.19.0-beta.67.tgz#fe44a243974bf307c9a0694114ab45289734c7f9" integrity sha512-rpxUsE/te2LN4B/erI108uaAhuLTUsnRl9zIZgcqMqZGFRqDUTtyVM05jIA/8A32g06wFd3WioTkeKc6ow+sLg== </ins> <del> xterm@4.19.0-beta.60: version "4.19.0-beta.60" resolved "https://registry.yarnpkg.com/xterm/-/xterm-4.19.0-beta.60.tgz#de89d93153ae3ec17b53f3e5d03b8ea859126081" integrity sha512-YQjvp4xtSAyNm9+gF4OA5+QzkSWdKMCy4WABETpe7CsrEGx+mJVoXCZ9wgopmvwRXz7DeJvKM5dWz1HPjVLDtA== </del> <ins> xterm@4.19.0-beta.67: version "4.19.0-beta.67" resolved "https://registry.yarnpkg.com/xterm/-/xterm-4.19.0-beta.67.tgz#9a7d79be64469c91bb693b9f5a50b5a22e921cd3" integrity sha512-4bYTnT6g91N5QId1qPaiSvkpsxMQYpuPdPJItvBZFOcQLTuFSX85x5NeFuDvhNqi33eMFPimyGhzH/JvAV1v/Q== </ins> yallist@^4.0.0: version "4.0.0"


})); } } <ins> class EditSessionsStoreClient extends UserDataSyncStoreClient { _serviceBrand: any; } </ins>


const lastDot = value.lastIndexOf('.'); inputBox.value = value; <del> inputBox.focus(); inputBox.select({ start: 0, end: lastDot > 0 && !stat.isDirectory ? lastDot : value.length }); const done = once(async (success: boolean, finishEditing: boolean) => { </del> <ins> let isFinishableDisposeEvent = false; setTimeout(() => { // Check if disposed if (!inputBox.inputElement) { return; } inputBox.focus(); inputBox.select({ start: 0, end: lastDot > 0 && !stat.isDirectory ? lastDot : value.length }); isFinishableDisposeEvent = true; }, 0); const done = once(async (success: boolean) => { </ins> label.element.style.display = 'none'; const value = inputBox.value; dispose(toDispose); container.removeChild(label.element); <del> if (finishEditing) { // Timeout: once done rendering only then re-render #70902 setTimeout(() => editableData.onFinish(value, success), 0); } </del> <ins> // Timeout: once done rendering only then re-render #70902 setTimeout(() => editableData.onFinish(value, success), 0); </ins> }); const blurDisposable = DOM.addDisposableListener(inputBox.inputElement, DOM.EventType.BLUR, () => { <del> done(inputBox.isInputValid(), true); </del> <ins> done(inputBox.isInputValid()); </ins> }); const toDispose = [


export class NotebookOutlineEntryFactory { private cellOutlineEntryCache: Record<string, entryDesc[]> = {}; <del> private readonly cachedMarkdownOutlineEntries = new WeakMap<ICellViewModel, { alternativeId: number; headers: { depth: number, text: string }[] }>(); </del> <ins> private readonly cachedMarkdownOutlineEntries = new WeakMap<ICellViewModel, { alternativeId: number; headers: { depth: number; text: string }[] }>(); </ins> constructor( private readonly executionStateService: INotebookExecutionStateService ) { }


return; } <ins> if (this.isPasting) { return; } </ins> const builtinCompletionsConfig = this._configurationService.getValue<ITerminalSuggestConfiguration>(terminalSuggestConfigSection).builtinCompletions; if (!this._codeCompletionsRequested && builtinCompletionsConfig.pwshCode) { this._onAcceptedCompletion.fire(SuggestAddon.requestEnableCodeCompletionsSequence);


export interface UriComponents { scheme: string; <del> authority: string; path: string; query: string; fragment: string; </del> <ins> authority?: string; path?: string; query?: string; fragment?: string; } export function isUriComponents(thing: any): thing is UriComponents { if (!thing || typeof thing !== 'object') { return false; } return typeof (<UriComponents>thing).scheme === 'string' && (typeof (<UriComponents>thing).authority === 'string' || typeof (<UriComponents>thing).authority === 'undefined') && (typeof (<UriComponents>thing).path === 'string' || typeof (<UriComponents>thing).path === 'undefined') && (typeof (<UriComponents>thing).query === 'string' || typeof (<UriComponents>thing).query === 'undefined') && (typeof (<UriComponents>thing).fragment === 'string' || typeof (<UriComponents>thing).fragment === 'undefined'); </ins> } interface UriState extends UriComponents { $mid: MarshalledId.Uri; <del> external: string; fsPath: string; _sep: 1 | undefined; </del> <ins> external?: string; fsPath?: string; _sep?: 1; </ins> } const _pathSepMarker = isWindows ? 1 : undefined;


throw e; } <del> let label; if (claims.name && claims.email) { label = `${claims.name} - ${claims.email}`; } else { label = claims.email ?? claims.unique_name ?? claims.preferred_username ?? 'user@example.com'; } </del> const id = `${claims.tid}/${(claims.oid ?? (claims.altsecid ?? '' + claims.ipd ?? ''))}`; const sessionId = existingId || `${id}/${randomUUID()}`; this._logger.trace(`[${scopeData.scopeStr}] '${sessionId}' Token response parsed successfully.`);


} async sendText(text: string, addNewLine: boolean): Promise<void> { <del> // Apply bracketed paste sequences if the terminal has the mode enabled, this will prevent // the text from triggering keybindings https://github.com/microsoft/vscode/issues/153592 if (this.xterm?.raw.modes.bracketedPasteMode) { text = `x1b[200~${text}x1b[201~`; } </del> // Normalize line endings to 'enter' press. text = text.replace(/r?n/g, 'r'); if (addNewLine && text[text.length - 1] !== 'r') {


); } <del> for (const [profileName, value] of Object.entries(configProfiles || {})) { if (value === null) { detectedProfiles.delete(profileName); } detectedProfiles.set(profileName, value); } </del> <ins> applyConfigProfilesToMap(configProfiles, detectedProfiles); </ins> const resultProfiles: ITerminalProfile[] = await transformToTerminalProfiles(detectedProfiles.entries(), statProvider, logService, variableResolver, workspaceFolder);


}, () => this.extensionManagementService.uninstallExtensions(extensionsToUninstall).then(() => undefined)); } <ins> private getAllPackExtensionsToUninstall(extension: ILocalExtension, installed: IExtension[], checked: ILocalExtension[] = []): ILocalExtension[] { if (checked.some(e => areSameExtensions(e.identifier, extension.identifier))) { return []; } checked.push(extension); const extensionsPack = extension.manifest.extensionPack ?? []; if (extensionsPack.length) { const packedExtensions: ILocalExtension[] = []; for (const i of installed) { if (i.local && !i.isBuiltin && extensionsPack.some(id => areSameExtensions({ id }, i.identifier))) { packedExtensions.push(i.local); } } const packOfPackedExtensions: ILocalExtension[] = []; for (const packedExtension of packedExtensions) { packOfPackedExtensions.push(...this.getAllPackExtensionsToUninstall(packedExtension, installed, checked)); } return [...packedExtensions, ...packOfPackedExtensions]; } return []; } </ins> private getErrorMessageForUninstallingAnExtensionWithDependents(extension: IExtension, dependents: IExtension[]): string { if (dependents.length === 1) { return nls.localize('singleDependentUninstallError', "Cannot uninstall '{0}' extension alone. '{1}' extension depends on this. Do you want to uninstall all these extensions?", extension.displayName, dependents[0].displayName);


} } <del> class SelectionToWatchExpressionsAction extends EditorAction { </del> <ins> export class SelectionToWatchExpressionsAction extends EditorAction { public static readonly ID = 'editor.debug.action.selectionToWatch'; public static readonly LABEL = nls.localize('addToWatch', "Add to Watch"); </ins> constructor() { super({ <del> id: 'editor.debug.action.selectionToWatch', label: nls.localize('addToWatch', "Add to Watch"), alias: 'Add to Watch', </del> <ins> id: SelectionToWatchExpressionsAction.ID, label: SelectionToWatchExpressionsAction.LABEL, alias: 'Debug: Add to Watch', </ins> precondition: ContextKeyExpr.and(EditorContextKeys.hasNonEmptySelection, CONTEXT_IN_DEBUG_MODE, EditorContextKeys.editorTextFocus), contextMenuOpts: { group: 'debug',


} public get capabilities(): WorkingCopyCapabilities { <del> return 0; </del> <ins> return WorkingCopyCapabilities.None; </ins> } public isDirty(): boolean {


}) .text(this.feedback).attr('required', 'required') .on('keyup', () => { <del> $charCounter.text('(' + (FeedbackDropdown.MAX_FEEDBACK_CHARS - this.feedbackDescriptionInput.value.length) + ' ' + nls.localize("characters left", "characters left") + ')'); </del> <ins> $charCounter.text(this.getCharCountText(this.feedbackDescriptionInput.value.length)); </ins> this.feedbackDescriptionInput.value ? this.sendButton.removeAttribute('disabled') : this.sendButton.attr('disabled', ''); }) .appendTo($form).domFocus().getHTMLElement();


import { CommandsRegistry, ICommandHandler, ICommandService } from 'vs/platform/commands/common/commands'; import { ConfigurationTarget, IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { ConfigurationScope, Extensions as ConfigurationExtensions, IConfigurationRegistry } from 'vs/platform/configuration/common/configurationRegistry'; <del> import { ContextKeyEqualsExpr, ContextKeyExpr, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; </del> <ins> import { ContextKeyAndExpr, ContextKeyEqualsExpr, ContextKeyExpr, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; </ins> import { IFileService } from 'vs/platform/files/common/files'; import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors'; import { registerSingleton } from 'vs/platform/instantiation/common/extensions';


import { DiffEditorEditors } from 'vs/editor/browser/widget/diffEditorWidget2/diffEditorEditors'; import { DiffEditorViewModel } from 'vs/editor/browser/widget/diffEditorWidget2/diffEditorViewModel'; import { appendRemoveOnDispose } from 'vs/editor/browser/widget/diffEditorWidget2/utils'; <del> import { EditorLayoutInfo } from 'vs/editor/common/config/editorOptions'; </del> <ins> import { EditorLayoutInfo, EditorOption } from 'vs/editor/common/config/editorOptions'; </ins> import { LineRange } from 'vs/editor/common/core/lineRange'; import { Position } from 'vs/editor/common/core/position'; import { OverviewRulerZone } from 'vs/editor/common/viewModel/overviewZoneManager';


import { ICommandService } from 'vs/platform/commands/common/commands'; import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace'; import { IFileService } from 'vs/platform/files/common/files'; <del> import { IDebugService, State, IDebugSession, IThread, IEnablement, IBreakpoint, IStackFrame, REPL_ID, IConfig } </del> <ins> import { IDebugService, State, IDebugSession, IThread, IEnablement, IBreakpoint, IStackFrame, REPL_ID } </ins> from 'vs/workbench/parts/debug/common/debug'; import { Variable, Expression, Thread, Breakpoint } from 'vs/workbench/parts/debug/common/debugModel'; import { IPartService } from 'vs/workbench/services/part/common/partService';


"customEditor.imagePreview.displayName": "Image Preview", "customEditor.videoPreview.displayName": "Video Preview", "command.zoomIn": "Zoom in", <del> "command.zoomOut": "Zoom out" </del> <ins> "command.zoomOut": "Zoom out", "command.copyImage": "Copy" </ins> }


<del> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><style>.st0{opacity:0}.st0,.st1{fill:#f6f6f6}.st2{fill:#424242}.st3{fill:#f0eff1}</style><g id="outline"><path class="st0" d="M0 0h16v16H0z"/><path class="st1" d="M5 1v5H0v9h11v-2.586l1 1 4-4V1H5zm5 3v2L8 4.586V4h2zm-2 8H3V9h5v3z"/></g><g id="icon_x5F_bg"><path class="st2" d="M3 9h2v2H3zM6 10h2v2H6zM14 3v3h.586L15 5.586V2H6v4h1V3z"/><path class="st2" d="M9 10.414V13H2V8h6V7H1v7h9V11.414zM9.414 6H10V4H8v.586z"/><path class="st2" d="M13 5h-2v4L9 7v2l3 3 3-3V7l-2 2z"/></g><g id="icon_x5F_fg"><path class="st3" d="M8 9.414V8H2v5h7v-2.586l-1-1zM5 11H3V9h2v2zm3 1H6v-2h2v2zM8 4.586V4h6V3H7v3h1z"/></g></svg> </del>  No newline at end of file <ins> <svg fill="none" height="16" viewBox="0 0 16 16" width="16" xmlns="http://www.w3.org/2000/svg"><path d="m5 1v5h-5v9h11v-2.586l1 1 4-4v-8.414zm5 3v2l-2-1.414v-.586zm-2 8h-5v-3h5z" fill="#f6f6f6"/><g fill="#424242"><path d="m3 9h2v2h-2zm3 1h2v2h-2zm8-7v3h.586l.414-.414v-3.586h-9v4h1v-3z"/><path d="m9 10.414v2.586h-7v-5h6v-1h-7v7h9v-2.586zm.414-4.414h.586v-2h-2v.586z"/><path d="m13 5h-2v4l-2-2v2l3 3 3-3v-2l-2 2z"/></g><path d="m8 9.414v-1.414h-6v5h7v-2.586zm-3 1.586h-2v-2h2zm3 1h-2v-2h2zm0-7.414v-.586h6v-1h-7v3h1z" fill="#f0eff1"/></svg> </ins>  No newline at end of file


// Send data if the pty is ready this._process.send({ event: 'input', <del> data: this._sanitizeInput(data) </del> <ins> data </ins> }); } else { // If the pty is not ready, queue the data received from


import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService'; import { BrowserLifecycleService } from 'vs/workbench/services/lifecycle/browser/lifecycleService'; import { ILifecycleService } from 'vs/workbench/services/lifecycle/common/lifecycle'; <ins> import { IHostService } from 'vs/workbench/services/host/browser/host'; </ins> export class BrowserWindow extends Disposable {


fn print_listening(log: &log::Logger, tunnel_name: &str) { debug!(log, "VS Code Server is listening for incoming connections"); <del> let extension_name = "+ms-vscode.remote-server"; </del> let home_dir = dirs::home_dir().unwrap_or_else(|| PathBuf::from("")); let current_dir = env::current_dir().unwrap_or_else(|_| PathBuf::from(""));


document: vscode.TextDocument, link: string, ): { uri: vscode.Uri, tooltip?: string } | undefined { <del> const externalSchemeUri = getUriForLinkWithKnownExternalScheme(link); </del> <ins> const cleanLink = stripAngleBrackets(link); const externalSchemeUri = getUriForLinkWithKnownExternalScheme(cleanLink); </ins> if (externalSchemeUri) { // Normalize VS Code links to target currently running version if (isOfScheme(Schemes.vscode, link) || isOfScheme(Schemes['vscode-insiders'], link)) {


export enum MarkdownPreviewSecurityLevel { Strict = 0, AllowInsecureContent = 1, <del> AllowScriptsAndAllContent = 2 </del> <ins> AllowScriptsAndAllContent = 2, AllowInsecureLocalContent = 3 </ins> } export interface ContentSecurityPolicyArbiter {


} } <del> private updateImageWatchers(containingImages: { src: string }[]) { const srcs = new Set(containingImages.map(img => img.src)); </del> <ins> private updateImageWatchers(srcs: Set<string>) { </ins> // Delete stale file watchers. for (const [src, watcher] of this._fileWatchersBySrc) { if (!srcs.has(src)) {


} } } <ins> function getExtensionName(id: string, extensionService: IExtensionService): string { return extensionService.extensions.find(e => e.id === id)?.displayName || id; } </ins>


/* Right aligned */ <del> .monaco-workbench .activitybar.right > .content :not(.monaco-menu) > .monaco-action-bar .action-label:not(.codicon) { </del> <ins> .monaco-workbench .activitybar.right > .content :not(.monaco-menu) > .monaco-action-bar .action-label:not(.codicon):not(.profile-activity-item) { </ins> margin-left: 0; padding: 0 48px 0 0; background-position: calc(100% - 9px) center;


backups.folderWorkspaces.forEach(workspacePath => { const backupPath = path.join(this.backupHome, this.getWorkspaceHash(workspacePath)); <del> if (!this.hasBackupsSync(backupPath)) { </del> <ins> const hasBackups = this.hasBackupsSync(backupPath); const missingWorkspace = hasBackups && !fs.existsSync(workspacePath); // If the folder has no backups, make sure to delete it // If the folder has backups, but the target workspace is missing, convert backups to empty ones if (!hasBackups || missingWorkspace) { </ins> const backupWorkspace = this.sanitizePath(workspacePath); staleBackupWorkspaces.push({ workspaceIdentifier: Uri.file(backupWorkspace).fsPath, backupPath, isEmptyWorkspace: false }); <ins> if (missingWorkspace) { const identifier = this.pushBackupPathsSync(this.getRandomEmptyWorkspaceId(), true /* is empty workspace */); const newEmptyWorkspaceBackupPath = path.join(path.dirname(backupPath), identifier); try { fs.renameSync(backupPath, newEmptyWorkspaceBackupPath); } catch (ex) { console.error(`Backup: Could not rename backup folder for missing workspace: ${ex.toString()}`); this.removeBackupPathSync(identifier, true); } } </ins> } });


} } <del> // Handle empty to open (only if no other window opened) if (usedWindows.length === 0 || filesToOpen) { if (filesToOpen && !emptyToOpen) { emptyToOpen++; } </del> <ins> // Open empty window either if enforced or when files still have to open if (filesToOpen || openOneEmptyWindow) { </ins> const remoteAuthority = filesToOpen ? filesToOpen.remoteAuthority : openConfig.remoteAuthority; <del> for (let i = 0; i < emptyToOpen; i++) { addUsedWindow(await this.doOpenEmpty(openConfig, openFolderInNewWindow, remoteAuthority, filesToOpen), !!filesToOpen); // any other window to open must open in new window then openFolderInNewWindow = true; } </del> <ins> addUsedWindow(await this.doOpenEmpty(openConfig, openFolderInNewWindow, remoteAuthority, filesToOpen), !!filesToOpen); </ins> } return { windows: distinct(usedWindows), filesOpenedInWindow };


} .action-widget .monaco-list .monaco-list-row.action.focused:not(.option-disabled) { <del> background-color: var(--vscode-quickInputList-focusBackground); </del> <ins> background-color: var(--vscode-quickInputList-focusBackground) !important; </ins> color: var(--vscode-quickInputList-focusForeground); outline: 1px solid var(--vscode-menu-selectionBorder, transparent); outline-offset: -1px; } .action-widget .monaco-list-row.group-header { <del> color: var(--vscode-pickerGroup-foreground); </del> <ins> color: var(--vscode-pickerGroup-foreground) !important; </ins> font-weight: 600; }


id: 'breadcrumbs.toggle', title: { value: localize('cmd.toggle', "Toggle Breadcrumbs"), <del> mnemonicTitle: localize('miBreadcrumbs', "Toggle &&Breadcrumbs"), </del> <ins> mnemonicTitle: localize({ key: 'miBreadcrumbs', comment: ['&& denotes a mnemonic'] }, "Toggle &&Breadcrumbs"), </ins> original: 'Toggle Breadcrumbs', }, category: Categories.View, toggled: { condition: ContextKeyExpr.equals('config.breadcrumbs.enabled', true), title: localize('cmd.toggle2', "Breadcrumbs"), <del> mnemonicTitle: localize('miBreadcrumbs2', "&&Breadcrumbs") </del> <ins> mnemonicTitle: localize({ key: 'miBreadcrumbs2', comment: ['&& denotes a mnemonic'] }, "&&Breadcrumbs") </ins> }, menu: [ { id: MenuId.CommandPalette },


export interface MainThreadCommandsShape extends IDisposable { $registerCommand(id: string): void; $unregisterCommand(id: string): void; <del> $executeCommand<T>(id: string, args: any[], retry: boolean): Promise<T | undefined>; </del> <ins> $executeCommand<T>(id: string, args: any[] | SerializableObjectWithBuffers<any[]>, retry: boolean): Promise<T | undefined>; </ins> $getCommands(): Promise<string[]>; }


<del> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><defs><style>.icon-canvas-transparent,.icon-vs-out{fill:#f6f6f6;}.icon-canvas-transparent{opacity:0;}.icon-vs-bg{fill:#424242;}.icon-vs-action-blue{fill:#00539c;}</style></defs><title>Compare_16x</title><g id="canvas"><path class="icon-canvas-transparent" d="M16,0V16H0V0Z"/></g><g id="outline" style="display: none;"><path class="icon-vs-out" d="M16,11H12.121l1.939,1.94a1.5,1.5,0,1,1-2.12,2.12L9.433,12.554A4.4,4.4,0,0,1,9,12.735V16H0V5H4.706A4.445,4.445,0,0,1,7,4.051V0h5.621L16,3.379Z" style="display: none;"/></g><g id="iconBg"><path class="icon-vs-bg" d="M15,3.793V10H11.735a4.4,4.4,0,0,0,.237-1H14V4.207L11.793,2H9V4.276a4.485,4.485,0,0,0-1-.225V1h4.207ZM7,12.949V14H2V7H3.276a4.493,4.493,0,0,1,.486-1H1v9H8V12.972A4.612,4.612,0,0,1,7.5,13,4.342,4.342,0,0,1,7,12.949Z"/></g><g id="colorAction"><path class="icon-vs-action-blue" d="M13.354,13.646l-3-3a.545.545,0,0,0-.071-.047A3.462,3.462,0,0,0,11,8.5,3.5,3.5,0,1,0,7.5,12a3.462,3.462,0,0,0,2.1-.717.57.57,0,0,0,.047.07l3,3a.5.5,0,1,0,.708-.707ZM7.5,11A2.5,2.5,0,1,1,10,8.5,2.5,2.5,0,0,1,7.5,11Z"/></g></svg> </del>  No newline at end of file <ins> <svg fill="none" height="16" viewBox="0 0 16 16" width="16" xmlns="http://www.w3.org/2000/svg"><path clip-rule="evenodd" d="m6 12h-1c-.27-.02-.48-.11-.69-.31s-.3-.42-.31-.69v-6.28c.59-.34 1-.98 1-1.72 0-1.11-.89-2-2-2s-2 .89-2 2c0 .73.41 1.38 1 1.72v6.28c.03.78.34 1.47.94 2.06s1.28.91 2.06.94c0 0 1.02 0 1 0v2l3-3-3-3zm-3-10.2c.66 0 1.2.55 1.2 1.2s-.55 1.2-1.2 1.2-1.2-.55-1.2-1.2.55-1.2 1.2-1.2zm11 9.48c0-1.73 0-6.28 0-6.28-.03-.78-.34-1.47-.94-2.06s-1.28-.91-2.06-.94h-1v-2l-3 3 3 3v-2h1c.27.02.48.11.69.31s.3.42.31.69v6.28c-.59.34-1 .98-1 1.72 0 1.11.89 2 2 2s2-.89 2-2c0-.73-.41-1.38-1-1.72zm-1 2.92c-.66 0-1.2-.55-1.2-1.2s.55-1.2 1.2-1.2 1.2.55 1.2 1.2-.55 1.2-1.2 1.2z" fill="#424242" fill-rule="evenodd"/></svg> </ins>  No newline at end of file


position: relative; padding: 0 6px; margin-bottom: 4px; <del> align-items: center; </del> <ins> align-items: flex-end; </ins> justify-content: space-between; }


const pathSeparatorClause = '/'; // '":; are allowed in paths but they are often separators so ignore them // Also disallow  to prevent a catastropic backtracking case #24798 <del> const excludedPathCharactersClause = '[^0s!$`&*()[]+'":;]'; </del> <ins> const excludedPathCharactersClause = '[^0s!$`&*()[]'":;]'; </ins> /** A regex that matches paths in the form /foo, ~/foo, ./foo, ../foo, foo/bar */ export const unixLocalLinkClause = '((' + pathPrefix + '|(' + excludedPathCharactersClause + ')+)?(' + pathSeparatorClause + '(' + excludedPathCharactersClause + ')+)+)'; export const winDrivePrefix = '(?:?)?[a-zA-Z]:'; const winPathPrefix = '(' + winDrivePrefix + '|..?|~)'; const winPathSeparatorClause = '(|/)'; <del> const winExcludedPathCharactersClause = '[^0<>?|/s!$`&*()[]+'":;]'; </del> <ins> const winExcludedPathCharactersClause = '[^0<>?|/s!$`&*()[]'":;]'; </ins> /** A regex that matches paths in the form ?c:foo c:foo, ~foo, .foo, ..foo, foobar */ export const winLocalLinkClause = '((' + winPathPrefix + '|(' + winExcludedPathCharactersClause + ')+)?(' + winPathSeparatorClause + '(' + winExcludedPathCharactersClause + ')+)+)';


const resources: { originalUri: Uri | undefined; modifiedUri: Uri | undefined }[] = []; for (const change of stashChanges) { if (change.status === Status.INDEX_ADDED) { <del> resources.push({ originalUri: undefined, modifiedUri: toGitUri(change.uri, `stash@{${stash.index}}`) }); </del> <ins> resources.push({ originalUri: undefined, modifiedUri: toGitUri(change.uri, stash.hash) }); </ins> } else if (change.status === Status.DELETED) { <del> resources.push({ originalUri: change.uri, modifiedUri: undefined }); </del> <ins> resources.push({ originalUri: toGitUri(change.uri, stashParentCommit), modifiedUri: undefined }); </ins> } else if (change.status === Status.INDEX_RENAMED) { <del> resources.push({ originalUri: change.originalUri, modifiedUri: toGitUri(change.uri, `stash@{${stash.index}}`) }); </del> <ins> resources.push({ originalUri: toGitUri(change.originalUri, stashParentCommit), modifiedUri: toGitUri(change.uri, stash.hash) }); </ins> } else { <del> resources.push({ originalUri: change.uri, modifiedUri: toGitUri(change.uri, `stash@{${stash.index}}`) }); </del> <ins> resources.push({ originalUri: toGitUri(change.uri, stashParentCommit), modifiedUri: toGitUri(change.uri, stash.hash) }); </ins> } }


} } <ins> private _onReplaceInputKeyDown(e: IKeyboardEvent): void { if (e.equals(KeyCode.Enter)) { this.replaceOne(); e.preventDefault(); return; } } </ins> protected onInputChanged(): boolean { this._state.change({ searchString: this.inputValue }, false); // this._findModel.research();


import { IFileService } from 'vs/platform/files/common/files'; import { createFileStat } from 'vs/workbench/test/common/workbenchTestServices'; import { URI } from 'vs/base/common/uri'; <ins> import { ILogService, NullLogService } from 'vs/platform/log/common/log'; </ins> const unixLinks: (string | { link: string; resource: URI })[] = [ // Absolute


} } <del> private onEditorClosed(listenerDispose: IDisposable, resourcesToWaitFor: URI[], waitMarkerFile: URI): void { // In wait mode, listen to changes to the editors and wait until the files // are closed that the user wants to wait for. When this happens we delete // the wait marker file to signal to the outside that editing is done. if (resourcesToWaitFor.every(resource => !this.editorService.isOpen({ resource }))) { listenerDispose.dispose(); this.fileService.del(waitMarkerFile); } } </del> private onContextMenu(e: MouseEvent): void { if (e.target instanceof HTMLElement) { const target = <HTMLElement>e.target;


} private createSearchResultsView(container: HTMLElement): void { <del> this.resultsElement = dom.append(container, $('.results.show-file-icons')); </del> <ins> this.resultsElement = dom.append(container, $('.results.show-file-icons.file-icon-themable-tree')); </ins> const delegate = this.instantiationService.createInstance(SearchDelegate); const identityProvider: IIdentityProvider<RenderableMatch> = {


id: 'editor.action.toggleStickyScroll', title: { value: localize('toggleStickyScroll', "Toggle Sticky Scroll"), <del> mnemonicTitle: localize('mitoggleStickyScroll', "&&Toggle Sticky Scroll"), </del> <ins> mnemonicTitle: localize({ key: 'mitoggleStickyScroll', comment: ['&& denotes a mnemonic'] }, "&&Toggle Sticky Scroll"), </ins> original: 'Toggle Sticky Scroll', }, category: Categories.View, toggled: { condition: ContextKeyExpr.equals('config.editor.stickyScroll.enabled', true), title: localize('stickyScroll', "Sticky Scroll"), <del> mnemonicTitle: localize('miStickyScroll', "&&Sticky Scroll"), </del> <ins> mnemonicTitle: localize({ key: 'miStickyScroll', comment: ['&& denotes a mnemonic'] }, "&&Sticky Scroll"), </ins> }, menu: [ { id: MenuId.CommandPalette },


if (!disableServiceWorker) { hostMessaging.onMessage('did-load-resource', (_event, data) => { <del> navigator.serviceWorker.getRegistration().then(registration => { assertIsDefined(registration.active).postMessage({ channel: 'did-load-resource', data }, data.data?.buffer ? [data.data.buffer] : []); }); </del> <ins> assertIsDefined(navigator.serviceWorker.controller).postMessage({ channel: 'did-load-resource', data }, data.data?.buffer ? [data.data.buffer] : []); </ins> }); hostMessaging.onMessage('did-load-localhost', (_event, data) => { <del> navigator.serviceWorker.getRegistration().then(registration => { assertIsDefined(registration.active).postMessage({ channel: 'did-load-localhost', data }); }); </del> <ins> assertIsDefined(navigator.serviceWorker.controller).postMessage({ channel: 'did-load-localhost', data }); </ins> }); navigator.serviceWorker.addEventListener('message', event => {


disposables.length = 0; }); <del> test('sendText immediately after createTerminal should not throw', (done) => { disposables.push(window.onDidOpenTerminal(term => { try { equal(terminal, term); } catch (e) { done(e); return; } terminal.dispose(); disposables.push(window.onDidCloseTerminal(() => done())); })); </del> <ins> test('sendText immediately after createTerminal should not throw', async () => { </ins> const terminal = window.createTerminal(); <ins> const result = await new Promise<Terminal>(r => { disposables.push(window.onDidOpenTerminal(t => { if (t === terminal) { r(t); } })); }); equal(result, terminal); </ins> doesNotThrow(terminal.sendText.bind(terminal, 'echo "foo"')); <ins> await new Promise<void>(r => { disposables.push(window.onDidCloseTerminal(t => { if (t === terminal) { r(); } })); terminal.dispose(); }); </ins> }); (process.platform === 'linux' ? test.skip : test)('echo works in the default shell', (done) => {


editorService.openEditor({ resource: GettingStartedInput.RESOURCE, options: <GettingStartedEditorOptions>{ selectedCategory: selectedCategory, selectedStep: selectedStep, preserveFocus: toSide ?? false } <del> }).then((editor) => { </del> <ins> }, toSide ? SIDE_GROUP : undefined).then((editor) => { </ins> (editor as GettingStartedPage)?.makeCategoryVisibleWhenAvailable(selectedCategory, selectedStep); }); } } else { <del> editorService.openEditor({ resource: GettingStartedInput.RESOURCE }); </del> <ins> editorService.openEditor({ resource: GettingStartedInput.RESOURCE, options: <GettingStartedEditorOptions>{ preserveFocus: toSide ?? false } }, toSide ? SIDE_GROUP : undefined); </ins> } } });


this._onDidBlur.fire(); })); <del> this._register(this._inputEditor.onDidChangeCursorPosition(e => { const model = this._inputEditor.getModel(); if (!model) { return; } const atTop = e.position.column === 1 && e.position.lineNumber === 1; this.chatCursorAtTop.set(atTop); this.historyNavigationBackwardsEnablement.set(atTop); this.historyNavigationForewardsEnablement.set(e.position.equals(getLastPosition(model))); })); </del> this.toolbar = this._register(this.instantiationService.createInstance(MenuWorkbenchToolBar, inputContainer, this.options.menus.executeToolbar, { telemetrySource: this.options.menus.telemetrySource,


private applicationStorage: IStorage | undefined; private applicationStorageDatabase: IIndexedDBStorageDatabase | undefined; <del> private readonly applicationStoragePromise = new DeferredPromise<{ indededDb: IIndexedDBStorageDatabase; storage: IStorage }>(); </del> <ins> private readonly applicationStoragePromise = new DeferredPromise<{ indexedDb: IIndexedDBStorageDatabase; storage: IStorage }>(); </ins> private profileStorage: IStorage | undefined; private profileStorageDatabase: IIndexedDBStorageDatabase | undefined;


const repositoryPath = await window.withProgress( opts, <del> (progress, token) => this.git.clone(url!, parentPath, progress, token) </del> <ins> (progress, token) => this.git.clone(url!, parentPath!, progress, token) </ins> ); let message = localize('proposeopen', "Would you like to open the cloned repository?");


"@microsoft/1ds-post-js": "^3.2.13", "@vscode/iconv-lite-umd": "0.7.0", "@vscode/vscode-languagedetection": "1.0.21", <del> "@xterm/addon-canvas": "0.6.0-beta.19", "@xterm/addon-image": "0.7.0-beta.17", "@xterm/addon-search": "0.14.0-beta.19", "@xterm/addon-serialize": "0.12.0-beta.19", "@xterm/addon-unicode11": "0.7.0-beta.19", "@xterm/addon-webgl": "0.17.0-beta.19", "@xterm/xterm": "5.4.0-beta.19", </del> <ins> "@xterm/addon-canvas": "0.6.0-beta.20", "@xterm/addon-image": "0.7.0-beta.18", "@xterm/addon-search": "0.14.0-beta.20", "@xterm/addon-serialize": "0.12.0-beta.20", "@xterm/addon-unicode11": "0.7.0-beta.20", "@xterm/addon-webgl": "0.17.0-beta.20", "@xterm/xterm": "5.4.0-beta.20", </ins> "jschardet": "3.0.0", "tas-client-umd": "0.1.8", "vscode-oniguruma": "1.7.0",


// Modifed to not include the message as part of the marker key to work around // https://github.com/microsoft/vscode/issues/77475 if (markerData.message && useMessage) { <del> result.push(markerData.message.replace('¦', '¦')); </del> <ins> result.push(markerData.message.replace('¦', '¦')); </ins> } else { result.push(emptyString); }


assert.strictEqual(configurationResolverService.resolve(workspace, 'abc ${lineNumber} xyz'), `abc ${editorService.mockLineNumber} xyz`); }); <ins> test('current selected text', () => { assert.strictEqual(configurationResolverService.resolve(workspace, 'abc ${selectedText} xyz'), `abc ${editorService.mockSelectedText} xyz`); }); </ins> test('substitute many', () => { if (platform.isWindows) { assert.strictEqual(configurationResolverService.resolve(workspace, '${workspaceFolder} - ${workspaceFolder}'), 'VSCodeworkspaceLocation - VSCodeworkspaceLocation');


return; } <del> const session = await VoiceChatSessions.getInstance(instantiationService).start(controller, context); </del> <ins> session = await VoiceChatSessions.getInstance(instantiationService).start(controller, context); </ins> await holdMode; handle.dispose();


items.splice(0, 0, item); } <del> const working = repo.workingTreeGroup.resourceStates.find(r => r.resourceUri.fsPath === uri.fsPath); if (working) { const date = new Date(); const item = new GitTimelineItem('', index ? '~' : 'HEAD', localize('git.timeline.uncommitedChanges', 'Uncommitted Changes'), date.getTime(), 'working', 'git:file:working'); // TODO@eamodio: Replace with a better icon -- reflecting its status maybe? item.iconPath = new ThemeIcon('git-commit'); item.description = ''; item.setItemDetails(you, undefined, dateFormatter.format(date), Resource.getStatusText(working.type)); const cmd = this.commands.resolveTimelineOpenDiffCommand(item, uri); if (cmd) { item.command = { title: openComparison, command: cmd.command, arguments: cmd.arguments, }; } items.splice(0, 0, item); } </del> } return {


<del> { "comments": { "lineComment": "#", "blockComment": [ "#", " " ] }, "brackets": [ ["{", "}"], ["[", "]"], ["(", ")"] ], "autoClosingPairs": [ ["{", "}"], ["[", "]"], ["(", ")"], [""", """], ["'", "'"] ], "surroundingPairs": [ ["{", "}"], ["[", "]"], ["(", ")"], [""", """], ["'", "'"] ] } </del>  No newline at end of file


assert.ok(!fs.exists(service.toBackupPath(fooFile.fsPath))); assert.ok(!fs.exists(service.toBackupPath(barFile.fsPath))); <ins> // 4) backup workspace path points to a workspace that no longer exists // so it should convert the backup worspace to an empty workspace backup const fileBackups = path.join(service.toBackupPath(fooFile.fsPath), 'file'); fs.mkdirSync(service.toBackupPath(fooFile.fsPath)); fs.mkdirSync(service.toBackupPath(barFile.fsPath)); fs.mkdirSync(fileBackups); service.registerWindowForBackups(1, false, null, fooFile.fsPath); assert.equal(service.workspaceBackupPaths.length, 1); assert.equal(service.emptyWorkspaceBackupPaths.length, 0); fs.writeFileSync(path.join(fileBackups, 'backup.txt'), ''); service.loadSync(); assert.equal(service.workspaceBackupPaths.length, 0); assert.equal(service.emptyWorkspaceBackupPaths.length, 1); </ins> done(); });


//#endregion <del> readonly capabilities = 0; </del> <ins> readonly capabilities = WorkingCopyCapabilities.None; </ins> readonly name = basename(this.labelService.getUriLabel(this.resource));


}; for (let i = 0; i < this._regions.length; i++) { const foldRange = this._regions.toFoldRange(i); <del> if (!foldRange.isUserDefined && !foldRange.isRecovered || !containedBy(foldRange)) { </del> <ins> if (!foldRange.isUserDefined && !foldRange.isRecovered || !intersects(foldRange)) { </ins> newFoldingRanges.push(foldRange); } }


private _findMatchesInLine(searchRegex:RegExp, text:string, lineNumber:number, deltaOffset:number, counter:number, result:EditorCommon.IEditorRange[], limitResultCount:number): number { var m:RegExpExecArray; <ins> // Reset regex to search from the beginning searchRegex.lastIndex = 0; </ins> do { m = searchRegex.exec(text); if (m) { <del> result.push(new Range(lineNumber, m.index + 1 + deltaOffset, lineNumber, m.index + 1 + m[0].length + deltaOffset)); </del> <ins> var range = new Range(lineNumber, m.index + 1 + deltaOffset, lineNumber, m.index + 1 + m[0].length + deltaOffset); // Exit early if the regex matches the same range if (range.equalsRange(result[result.length - 1])) { return counter; } result.push(range); </ins> counter++; if (counter >= limitResultCount) { return counter;


constructor( @IExtensionsWorkbenchService private readonly extensionsWorkbenchService: IExtensionsWorkbenchService, <del> @IPaneCompositePartService private readonly paneCompositeService: IPaneCompositePartService, </del> @IModelService private readonly modelService: IModelService, @ILanguageService private readonly languageService: ILanguageService, @IProductService productService: IProductService, <del> @INotificationService private readonly notificationService: INotificationService, @ITelemetryService private readonly telemetryService: ITelemetryService, </del> @IStorageService private readonly storageService: IStorageService, @IExtensionRecommendationNotificationService private readonly extensionRecommendationNotificationService: IExtensionRecommendationNotificationService, @IExtensionIgnoredRecommendationsService private readonly extensionIgnoredRecommendationsService: IExtensionIgnoredRecommendationsService, @IWorkspaceContextService private readonly workspaceContextService: IWorkspaceContextService, <del> @IExtensionManagementServerService private readonly extensionManagementServerService: IExtensionManagementServerService, </del> ) { super(); this.fileOpenRecommendations = {};


} } } <ins> KeybindingsRegistry.registerKeybindingRule({ id: 'undo', weight: 1000, primary: KeyMod.CtrlCmd | KeyCode.LeftArrow, when: ContextKeyExpr.and(EditorContextKeys.writable, ContextKeyExpr.or(GhostTextController.inlineSuggestionVisible, GhostTextController.inlineSuggestionJustCommitted)), }); </ins>


import { onUnexpectedError, isPromiseCanceledError } from 'vs/base/common/errors'; import { IWindowService } from 'vs/platform/windows/common/windows'; import { TPromise } from 'vs/base/common/winjs.base'; <del> import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace'; </del> <ins> import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace'; </ins> import { IConfigurationService, ConfigurationTarget } from 'vs/platform/configuration/common/configuration'; import { localize } from 'vs/nls'; import { Action } from 'vs/base/common/actions';


isExtensionOwnedTerminal?: boolean; useShellEnvironment?: boolean; location?: TerminalLocation | { viewColumn: number, preserveFocus?: boolean } | { parentTerminal: ExtHostTerminalIdentifier } | { splitActiveTerminal: boolean }; <ins> disablePersistence?: boolean; </ins> } export interface MainThreadTerminalServiceShape extends IDisposable {


import { registerIcon } from 'vs/platform/theme/common/iconRegistry'; import { UntitledTextEditorInputSerializer, UntitledTextEditorWorkingCopyEditorHandler } from 'vs/workbench/services/untitled/common/untitledTextEditorHandler'; import { DynamicEditorConfigurations } from 'vs/workbench/browser/parts/editor/editorConfiguration'; <del> import { EditorActionsDefaultAction, EditorActionsTitleBarAction, HideEditorActionsAction, HideEditorTabsAction, ShowMultipleEditorTabsAction, ShowSingleEditorTabAction, ZenHideEditorTabsAction, ZenShowMultipleEditorTabsAction, ZenShowSingleEditorTabAction } from 'vs/workbench/browser/actions/layoutActions'; </del> <ins> import { ConfigureEditorAction, ConfigureEditorTabsAction, EditorActionsDefaultAction, EditorActionsTitleBarAction, HideEditorActionsAction, HideEditorTabsAction, ShowMultipleEditorTabsAction, ShowSingleEditorTabAction, ZenHideEditorTabsAction, ZenShowMultipleEditorTabsAction, ZenShowSingleEditorTabAction } from 'vs/workbench/browser/actions/layoutActions'; </ins> import { ICommandAction } from 'vs/platform/action/common/action'; import { EditorContextKeys } from 'vs/editor/common/editorContextKeys';


sortedIndexes.push(this.sortedIndexes[i++] + diff); } <del> const length = this.length + diff; if (this.sortedIndexes.length > 0 && sortedIndexes.length === 0 && length > 0) { const first = this.sortedIndexes.find(index => index >= start) ?? length - 1; sortedIndexes.push(Math.min(first, length - 1)); } </del> this.renderer.splice(start, deleteCount, elements.length); this._set(sortedIndexes, sortedIndexes); <del> this.length = length; </del> } renderIndex(index: number, container: HTMLElement): void {


provideRefactorNotApplicableReason: true, generateReturnInDocTemplate: config.get<boolean>('suggest.jsdoc.generateReturns', true), includeCompletionsForImportStatements: config.get<boolean>('suggest.includeCompletionsForImportStatements', true), <del> includeCompletionsWithSnippetText: config.get<boolean>('suggest.includeCompletionsWithSnippetText', true), </del> <ins> includeCompletionsWithSnippetText: true, </ins> includeCompletionsWithClassMemberSnippets: config.get<boolean>('suggest.classMemberSnippets.enabled', true), includeCompletionsWithObjectLiteralMethodSnippets: config.get<boolean>('suggest.objectLiteralMethodSnippets.enabled', true), autoImportFileExcludePatterns: this.getAutoImportFileExcludePatternsPreference(preferencesConfig, vscode.workspace.getWorkspaceFolder(document.uri)?.uri),


} export interface Stash { <del> index: number; description: string; branchName?: string; </del> <ins> readonly hash: string; readonly parents: string[]; readonly index: number; readonly description: string; readonly branchName?: string; </ins> } interface MutableRemote extends Remote {