import { IEditorGroupsService, IEditorGroup, GroupDirection, GroupLocation, GroupsOrder, preferredSideBySideGroupDirection, EditorGroupLayout } from 'vs/workbench/services/group/common/editorGroupsService'; import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; <del> import { CommandsRegistry } from 'vs/platform/commands/common/commands'; </del> <ins> import { CommandsRegistry, ICommandHandler } from 'vs/platform/commands/common/commands'; </ins> import { MenuRegistry, MenuId } from 'vs/platform/actions/common/actions'; export const CLOSE_SAVED_EDITORS_COMMAND_ID = 'workbench.action.closeUnmodifiedEditors';


} if (completion.command) { <del> await this._commandService .executeCommand(completion.command.id, ...(completion.command.arguments || [])) .then(undefined, onUnexpectedExternalError); </del> <ins> // Make sure the completion list will not be disposed. completion.source.addRef(); </ins> } <ins> // Reset before invoking the command, since the command might cause a follow up trigger. </ins> transaction(tx => { this._source.clear(tx); // Potentially, isActive will get set back to true by the typing or accept inline suggest event // if automatic inline suggestions are enabled. this._isActive.set(false, tx); }); <ins> if (completion.command) { await this._commandService .executeCommand(completion.command.id, ...(completion.command.arguments || [])) .then(undefined, onUnexpectedExternalError); completion.source.removeRef(); } </ins> } <del> public acceptNextWord(editor: ICodeEditor): void { this._acceptNext(editor, (pos, text) => { </del> <ins> public async acceptNextWord(editor: ICodeEditor): Promise<void> { await this._acceptNext(editor, (pos, text) => { </ins> const langId = this.textModel.getLanguageIdAtPosition(pos.lineNumber, pos.column); const config = this._languageConfigurationService.getLanguageConfiguration(langId); const wordRegExp = new RegExp(config.wordDefinition.source, config.wordDefinition.flags.replace('g', ''));


"pickerGroup.border": "#749351", "list.activeSelectionForeground": "#6c6c6c", "list.focusBackground": "#CADEB9", <ins> "list.hoverBackground": "#e0e0e0", </ins> "list.activeSelectionBackground": "#c4d9b1", "list.inactiveSelectionBackground": "#d3dbcd", "list.highlightForeground": "#9769dc",


if (!Types.isString(info.command)) { missingAttribute('command'); } <del> return this.commandService.executeCommand<string>(info.command, info.args).then(result => { </del> <ins> return this.userInputAccessQueue.queue(() => this.commandService.executeCommand<string>(info.command, info.args)).then(result => { </ins> if (typeof result === 'string' || Types.isUndefinedOrNull(result)) { return result; }


updated: !!existingExtension, isPreReleaseVersion: this.gallery.properties.isPreReleaseVersion, installedTimestamp: Date.now(), <del> pinned: this.options.installGivenVersion ? true : undefined, </del> <ins> pinned: this.options.installGivenVersion ? true : existingExtension?.pinned, </ins> preRelease: this.gallery.properties.isPreReleaseVersion || (isBoolean(this.options.installPreReleaseVersion) ? this.options.installPreReleaseVersion /* Respect the passed flag */


private static QUICK_INPUT_INPUT = `${QuickInput.QUICK_INPUT} .quick-input-box input`; private static QUICK_INPUT_ROW = `${QuickInput.QUICK_INPUT} .quick-input-list .monaco-list-row`; private static QUICK_INPUT_FOCUSED_ELEMENT = `${QuickInput.QUICK_INPUT_ROW}.focused .monaco-highlighted-label`; <del> private static QUICK_INPUT_ENTRY_LABEL = `${QuickInput.QUICK_INPUT_ROW} .label-name`; </del> <ins> // Note: this only grabs the label and not the description or detail private static QUICK_INPUT_ENTRY_LABEL = `${QuickInput.QUICK_INPUT_ROW} .quick-input-list-row > .monaco-icon-label .label-name`; </ins> private static QUICK_INPUT_ENTRY_LABEL_SPAN = `${QuickInput.QUICK_INPUT_ROW} .monaco-highlighted-label`; constructor(private code: Code) { }


} clearCache(cacheKey: string): void { <ins> // cancel the token this.sessions.get(cacheKey)?.dispose(); </ins> // with no reference to this, it will be removed from WeakMaps this.sessions.delete(cacheKey); } <del> private getSessionTokenSource(cacheKey: string | undefined): unknown { </del> <ins> private getSessionTokenSource(cacheKey: string | undefined): SessionLifecycle | undefined { </ins> if (!cacheKey) { return undefined; } if (!this.sessions.has(cacheKey)) { <del> this.sessions.set(cacheKey, new Object()); </del> <ins> this.sessions.set(cacheKey, new SessionLifecycle()); </ins> } return this.sessions.get(cacheKey);


this.applyStyles(); <ins> // Allows focus to switch to next/previous entry after tab into an actionbar item DOM.addDisposableListener(this.treeContainer.getHTMLElement(), DOM.EventType.KEY_DOWN, (e: KeyboardEvent) => { const keyboardEvent: StandardKeyboardEvent = new StandardKeyboardEvent(e); if (keyboardEvent.keyCode === KeyCode.DownArrow || keyboardEvent.keyCode === KeyCode.UpArrow || keyboardEvent.keyCode === KeyCode.PageDown || keyboardEvent.keyCode === KeyCode.PageUp) { DOM.EventHelper.stop(e, true); this.navigateInTree(keyboardEvent.keyCode, keyboardEvent.shiftKey); this.inputBox.inputElement.focus(); } }); </ins> return this.builder.getHTMLElement(); }


import { ICodeEditor } from '../../../browser/editorBrowser.js'; import { EditorAction, EditorCommand, ICommandOptions, registerEditorAction, registerEditorCommand, ServicesAccessor } from '../../../browser/editorExtensions.js'; import { ReplaceCommand } from '../../../common/commands/replaceCommand.js'; <del> import { EditorOption } from '../../../common/config/editorOptions.js'; </del> <ins> import { EditorOption, EditorOptions } from '../../../common/config/editorOptions.js'; </ins> import { CursorState } from '../../../common/cursorCommon.js'; import { CursorChangeReason } from '../../../common/cursorEvents.js'; import { DeleteWordContext, WordNavigationType, WordOperations } from '../../../common/cursor/cursorWordOperations.js';


protocol: information.tunnelFeatures.protocol === undefined ? true : information.tunnelFeatures.protocol, } : undefined; <del> this._proxy.$setTunnelProvider(tunnelFeatures); </del> <ins> this._proxy.$setTunnelProvider(tunnelFeatures, true); </ins> return Promise.resolve(toDisposable(() => { this._forwardPortProvider = undefined; <del> this._proxy.$setTunnelProvider(undefined); </del> <ins> this._proxy.$setTunnelProvider(undefined, false); </ins> })); }


private readonly _hasAssociatedFilePath: boolean, readonly viewType: string, private readonly _workingCopyManager: IFileWorkingCopyManager<NotebookFileWorkingCopyModel, NotebookFileWorkingCopyModel>, <del> @IFileService private readonly _fileService: IFileService </del> <ins> @IFileService private readonly _fileService: IFileService, @ILifecycleService lifecycleService: ILifecycleService </ins> ) { super(); <ins> if (this.viewType === 'interactive') { lifecycleService.onBeforeShutdown(async e => e.veto(this.onBeforeShutdown(), 'veto.InteractiveWindow')); } } private async onBeforeShutdown() { if (this._workingCopy?.isDirty()) { await this._workingCopy.save(); } return false; </ins> } override dispose(): void {


private _disposeFocusStickyScrollStore() { this._stickyScrollFocusedContextKey.set(false); <del> this._focusDisposableStore!.dispose(); </del> <ins> this._focusDisposableStore?.dispose(); </ins> this._focused = false; <ins> this._positionRevealed = false; this._onMouseDown = false; </ins> } public focus(): void { <ins> // If the mouse is down, do not focus on the sticky scroll if (this._onMouseDown) { this._onMouseDown = false; this._editor.focus(); return; } </ins> const focusState = this._stickyScrollFocusedContextKey.get(); if (focusState === true) { return;


return this._repository.getMergeBase(ref1, ref2); } <ins> tag(name: string, upstream: string): Promise<void> { return this._repository.tag(name, upstream); } deleteTag(name: string): Promise<void> { return this._repository.deleteTag(name); } </ins> status(): Promise<void> { return this._repository.status(); }


const stylingSchemeEntry = getStylingSchemeEntry(description, deprecationMessage); this.tokenStylingSchema.properties[id] = stylingSchemeEntry; <del> this.typeHierarchy = {}; </del> <ins> this.typeHierarchy = Object.create(null); </ins> } public registerTokenModifier(id: string, description: string, deprecationMessage?: string): void {


this._register(this.viewModel.searchResult.onChange((event) => this.onSearchResultsChanged(event))); this._register(this.onDidChangeBodyVisibility(visible => this.onVisibilityChanged(visible))); <ins> this.updateIndentStyles(this.themeService.getFileIconTheme()); this._register(this.themeService.onDidFileIconThemeChange(this.updateIndentStyles, this)); } private updateIndentStyles(theme: IFileIconTheme): void { this.resultsElement.classList.toggle('hide-arrows', this.isTreeLayoutViewVisible && theme.hidesExplorerArrows); </ins> } private onVisibilityChanged(visible: boolean): void {


if (activationEventsNode?.type === 'array' && activationEventsNode.children) { for (const activationEventNode of activationEventsNode.children) { const activationEvent = getNodeValue(activationEventNode); <ins> // Redundant Implicit Activation </ins> if (info.implicitActivationEvents?.has(activationEvent) && redundantImplicitActivationEventPrefixes.some((prefix) => activationEvent.startsWith(prefix))) { const start = document.positionAt(activationEventNode.offset); const end = document.positionAt(activationEventNode.offset + activationEventNode.length); diagnostics.push(new Diagnostic(new Range(start, end), redundantImplicitActivationEvent, DiagnosticSeverity.Warning)); <del> } else { for (const implicitActivationEventPrefix of reservedImplicitActivationEventPrefixes) { if (activationEvent.startsWith(implicitActivationEventPrefix)) { const start = document.positionAt(activationEventNode.offset); const end = document.positionAt(activationEventNode.offset + activationEventNode.length); diagnostics.push(new Diagnostic(new Range(start, end), implicitActivationEvent, DiagnosticSeverity.Error)); } </del> <ins> } // Reserved Implicit Activation for (const implicitActivationEventPrefix of reservedImplicitActivationEventPrefixes) { if (activationEvent.startsWith(implicitActivationEventPrefix)) { const start = document.positionAt(activationEventNode.offset); const end = document.positionAt(activationEventNode.offset + activationEventNode.length); diagnostics.push(new Diagnostic(new Range(start, end), implicitActivationEvent, DiagnosticSeverity.Error)); </ins> } } <ins> // Star activation if (activationEvent === '*') { const start = document.positionAt(activationEventNode.offset); const end = document.positionAt(activationEventNode.offset + activationEventNode.length); const diagnostic = new Diagnostic(new Range(start, end), starActivation, DiagnosticSeverity.Information); diagnostic.code = { value: 'star-activation', target: Uri.parse('https://code.visualstudio.com/api/references/activation-events#Start-up'), }; diagnostics.push(diagnostic); } </ins> } } }


public updateConfig(): void { const config = this._configHelper.config; <ins> this._safeSetOption('altClickMovesCursor', config.altClickMovesCursor); </ins> this._setCursorBlink(config.cursorBlinking); this._setCursorStyle(config.cursorStyle); this._setCursorWidth(config.cursorWidth);


alwaysFocused: true, verticalScrollMode: ScrollbarVisibility.Visible, ariaLabel: nls.localize('treeAriaLabel', "Quick Picker"), <del> keyboardSupport: this.options.keyboardSupport </del> <ins> keyboardSupport: this.options.keyboardSupport, preventRootFocus: true </ins> }); this.treeElement = this.tree.getHTMLElement();


name: string; value: string; type?: string; <ins> language?: string; expression?: string; </ins> hasNamedChildren: boolean; indexedChildrenCount: number; extensionId: string;


import { BackLayerWebView } from 'vs/workbench/contrib/notebook/browser/view/renderers/backLayerWebView'; import { CodeCellRenderer, MarkupCellRenderer, NotebookCellListDelegate } from 'vs/workbench/contrib/notebook/browser/view/renderers/cellRenderer'; import { IAckOutputHeight, IMarkupCellInitialization } from 'vs/workbench/contrib/notebook/browser/view/renderers/webviewMessages'; <del> import { CodeCellViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel'; </del> <ins> import { CodeCellViewModel, outputDisplayLimit } from 'vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel'; </ins> import { NotebookEventDispatcher } from 'vs/workbench/contrib/notebook/browser/viewModel/eventDispatcher'; import { MarkupCellViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/markupCellViewModel'; import { CellViewModel, NotebookViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/notebookViewModelImpl';


} } <ins> class GetStartedWithAccessibilityFeatures extends Action2 { static readonly ID = 'workbench.action.getStartedWithAccessibilityFeatures'; constructor() { super({ id: GetStartedWithAccessibilityFeatures.ID, title: localize2('getStartedWithAccessibilityFeatures', 'Get Started with Accessibility Features'), category: Categories.Help, f1: true, menu: { id: MenuId.MenubarHelpMenu, group: '1_welcome', order: 6 } }); } run(accessor: ServicesAccessor): void { const commandService = accessor.get(ICommandService); const accessibilityService = accessor.get(IAccessibilityService); commandService.executeCommand('workbench.action.openWalkthrough', accessibilityService.isScreenReaderOptimized() ? 'SetupScreenReader' : 'SetupAccessibility'); } } </ins> // --- Actions Registration if (KeybindingsReferenceAction.AVAILABLE) {


} .monaco-button-dropdown > .monaco-button.monaco-dropdown-button { <ins> border: 1px solid var(--vscode-button-border, transparent); </ins> border-left-width: 0 !important; border-radius: 0 2px 2px 0; }


"@vscode/windows-mutex": "^0.4.4", "@vscode/windows-process-tree": "^0.5.0", "@vscode/windows-registry": "^1.1.0", <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/headless": "5.4.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/headless": "5.4.0-beta.20", "@xterm/xterm": "5.4.0-beta.20", </ins> "graceful-fs": "4.2.11", "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.2",


} /** <ins> * Register an inlay hints provider. */ export function registerInlayHintsProvider(languageId: string, provider: modes.InlayHintsProvider): IDisposable { return modes.InlayHintsProviderRegistry.register(languageId, provider); } /** </ins> * Contains additional diagnostic information about the context in which * a [code action](#CodeActionProvider.provideCodeActions) is run. */


} .monaco-tree .monaco-tree-row > .content.actions > .primary-action-bar .action-label { <del> margin-right: 0.2em; </del> <ins> margin-right: 0.4em; </ins> margin-top: 4px; background-repeat: no-repeat; width: 16px;


border-color: var(--vscode-textBlockQuote-border); } <ins> kbd { color: var(--vscode-editor-foreground); border-radius: 3px; vertical-align: middle; padding: 1px 3px; 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); } </ins> ::-webkit-scrollbar { width: 10px; height: 10px;


return false; }); <del> let nextWidget: ReviewZoneWidget; if (idx === this._commentWidgets.length) { nextWidget = this._commentWidgets[0]; } else { nextWidget = sortedWidgets[idx]; </del> <ins> const nextWidget: ReviewZoneWidget | undefined = sortedWidgets[idx]; if (nextWidget !== undefined) { this.editor.setSelection(nextWidget.commentThread.range ?? new Range(1, 1, 1, 1)); nextWidget.reveal(undefined, CommentWidgetFocus.Widget); </ins> } <del> this.editor.setSelection(nextWidget.commentThread.range ?? new Range(1, 1, 1, 1)); nextWidget.reveal(undefined, CommentWidgetFocus.Widget); </del> } public previousCommentThread(): void {


previewManager.activePreview?.zoomOut(); })); <ins> disposables.push(vscode.commands.registerCommand('imagePreview.copyImage', () => { previewManager.activePreview?.copyImage(); })); </ins> return vscode.Disposable.from(...disposables); }


disturl "https://electronjs.org/headers" <del> target "25.8.0" ms_build_id "23503258" </del> <ins> target "25.8.1" ms_build_id "23779380" </ins> runtime "electron" build_from_source "true"


if (event.affectsConfiguration(TitlebarPart.configCommandCenter)) { this.updateTitle(); this._onDidChangeCommandCenterVisibility.fire(); <ins> this._onDidChange.fire(undefined); </ins> } }


} const outputs = viewCell.outputsViewModels; <del> for (const output of outputs) { </del> <ins> for (const output of outputs.slice(0, outputDisplayLimit)) { </ins> const [mimeTypes, pick] = output.resolveMimeTypes(this.textModel!, undefined); if (!mimeTypes.find(mimeType => mimeType.isTrusted) || mimeTypes.length === 0) { continue;


<textarea name="description" id="description" placeholder="${escape(localize('details', "Please enter details."))}" required></textarea>

${escape(localize('descriptionEmptyValidation', "A description is required."))}

${escape(localize('descriptionTooShortValidation', "Please provide a longer description."))}


import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService'; import { ISelection } from 'vs/editor/common/core/selection'; import { TestItemImpl } from 'vs/workbench/api/common/extHostTestingPrivateApi'; <ins> import { VSBuffer } from 'vs/base/common/buffer'; import { SerializableObjectWithBuffers } from 'vs/workbench/services/extensions/common/proxyIdentifier'; </ins> interface CommandHandler { callback: Function;


weight = KeybindingWeight.ExternalExtension + idx; } <ins> let commandAction = MenuRegistry.getCommand(command); let precondition = commandAction && commandAction.precondition; let fullWhen: ContextKeyExpr | undefined; if (when && precondition) { fullWhen = ContextKeyExpr.and(precondition, ContextKeyExpr.deserialize(when)); } else if (when) { fullWhen = ContextKeyExpr.deserialize(when); } else if (precondition) { fullWhen = precondition; } </ins> let desc: IKeybindingRule2 = { id: command, args, <del> when: ContextKeyExpr.deserialize(when), </del> <ins> when: fullWhen, </ins> weight: weight, primary: KeybindingParser.parseKeybinding(key, OS), mac: mac ? { primary: KeybindingParser.parseKeybinding(mac, OS) } : null,


// Note: When this action is executed from the process explorer, a config is passed. For all // other cases it is run with no arguments. <del> public run(config?: IConfig): Promise<any> { if (config && 'type' in config && 'request' in config) { return this.debugService.startDebugging(undefined, config, this.isNoDebug()); } </del> <ins> public run(): Promise<any> { </ins> const configurationManager = this.debugService.getConfigurationManager(); let launch = configurationManager.selectedConfiguration.launch; if (!launch || launch.getConfigurationNames().length === 0) {


* ------------------------------------------------------------------------------------------ */ 'use strict'; <del> import { env, languages, commands, workspace, window, ExtensionContext, Memento, IndentAction, Diagnostic, DiagnosticCollection, Range, DocumentFilter, Disposable } from 'vscode'; </del> <ins> import { env, languages, commands, workspace, window, ExtensionContext, Memento, IndentAction, Diagnostic, DiagnosticCollection, Range, DocumentFilter, Disposable, Uri } from 'vscode'; </ins> // This must be the first statement otherwise modules might got loaded with // the wrong locale.


resolved "https://registry.yarnpkg.com/vscode-textmate/-/vscode-textmate-7.0.1.tgz#8118a32b02735dccd14f893b495fa5389ad7de79" integrity sha512-zQ5U/nuXAAMsh691FtV0wPz89nSkHbs+IQV8FDk+wew9BlSDhf4UmWGlWJfTR2Ti6xZv87Tj5fENzKf6Qk7aLw== <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> 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@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>


private readonly _onDispose = this._register(new Emitter<void>()); readonly onDispose = this._onDispose.event; <del> readonly capabilities = 0; </del> <ins> readonly capabilities = WorkingCopyCapabilities.None; </ins> readonly name = basename(this.resource);


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


export interface IActiveEditorActions { readonly actions: IToolbarActions; <del> readonly onDidChange: Event<IMenuChangeEvent>; </del> <ins> readonly onDidChange: Event<IMenuChangeEvent | void>; </ins> } export interface IEditorGroup {


'./foo', '../foo', '/foo/bar', <del> 'foo/bar' </del> <ins> '/foo/bar+more', 'foo/bar', 'foo/bar+more', </ins> ]; const windowsLinks = [


*/ getBoundaryScore?(length: number): number; } <del> export class SequenceFromIntArray implements ISequence { constructor(private readonly arr: number[]) { } getElement(offset: number): number { return this.arr[offset]; } get length(): number { return this.arr.length; } } </del>


import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers'; import { revive } from 'vs/base/common/marshalling'; import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions'; <ins> import { SerializableObjectWithBuffers } from 'vs/workbench/services/extensions/common/proxyIdentifier'; </ins> @extHostNamedCustomer(MainContext.MainThreadCommands) export class MainThreadCommands implements MainThreadCommandsShape {


import { LiveTestResult } from 'vs/workbench/contrib/testing/common/testResult'; import { ITestResultService } from 'vs/workbench/contrib/testing/common/testResultService'; import { IMainThreadTestController, ITestRootProvider, ITestService } from 'vs/workbench/contrib/testing/common/testService'; <del> import { CoverageDetails, ExtensionRunTestsRequest, IFileCoverage, ITestItem, ITestMessage, ITestRunProfile, ITestRunTask, ResolvedTestRunRequest, TestResultState, TestsDiffOp } from 'vs/workbench/contrib/testing/common/testTypes'; </del> <ins> import { CoverageDetails, ExtensionRunTestsRequest, IFileCoverage, ITestItem, ITestMessage, ITestRunProfile, ITestRunTask, ResolvedTestRunRequest, TestResultState, TestRunProfileBitset, TestsDiffOp } from 'vs/workbench/contrib/testing/common/testTypes'; </ins> import { IExtHostContext, extHostNamedCustomer } from 'vs/workbench/services/extensions/common/extHostCustomers'; import { ExtHostContext, ExtHostTestingShape, ILocationDto, ITestControllerPatch, MainContext, MainThreadTestingShape } from '../common/extHost.protocol';


private didLayout = false; private emptyViews: ISplitViewView<{ top: number; left: number }>[] | undefined; private readonly splitViewDisposables = new DisposableStore(); <del> private centeredLayoutFixedWidth = true; </del> constructor( private container: HTMLElement, private view: IView, <del> public state: CenteredViewState = { ...defaultState } </del> <ins> public state: CenteredViewState = { ...defaultState }, private centeredLayoutFixedWidth: boolean = false </ins> ) { this.container.appendChild(this.view.element); // Make sure to hide the split view overflow like sashes #52892


resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.207.tgz#9c3310ebace2952903d05dcaba8abe3a4ed44c01" integrity sha512-piH7MJDJp4rJCduWbVvmUd59AUne1AFBJ8JaRQvk0KzNTSUnZrVXHCZc+eg+CGE4OujkcLJznhGKD6tuAshj5Q== <del> electron@25.8.0: version "25.8.0" resolved "https://registry.yarnpkg.com/electron/-/electron-25.8.0.tgz#60c84f1f256924ac5a0aff13276b901b0c43767a" integrity sha512-T3kC1a/3ntSaYMCVVfUUc9v7myPzi6J2GP0Ad/CyfWKDPp054dGyKxb2EEjKnxQQ7wfjsT1JTEdBG04x6ekVBw== </del> <ins> electron@25.8.1: version "25.8.1" resolved "https://registry.yarnpkg.com/electron/-/electron-25.8.1.tgz#092fab5a833db4d9240d4d6f36218cf7ca954f86" integrity sha512-GtcP1nMrROZfFg0+mhyj1hamrHvukfF6of2B/pcWxmWkd5FVY1NJib0tlhiorFZRzQN5Z+APLPr7aMolt7i2AQ== </ins> dependencies: "@electron/get" "^2.0.0" "@types/node" "^18.11.18"


applyZoom(webFrame.getZoomLevel() - 1); } }; <del> } </del>  No newline at end of file <ins> } </ins>


'navigation', shouldInlineGroup ); <ins> } else { // If there is no active pane in the group (it's the last group and it's empty) // Trigger the change event when the active editor changes const _onDidChange = new Emitter<void>(); onDidChange = _onDidChange.event; disposables.add(this.onDidActiveEditorChange(() => _onDidChange.fire())); </ins> } return { actions: { primary, secondary }, onDidChange };


import { IChatCommandButton, IChatContentReference, IChatFollowup, IChatProgressMessage, IChatResponseErrorDetails, IChatResponseProgressFileTreeData, IChatUsedContext, InteractiveSessionVoteDirection } from 'vs/workbench/contrib/chat/common/chatService'; import { countWords } from 'vs/workbench/contrib/chat/common/chatWordCounter'; import { CodeBlockModelCollection } from './codeBlockModelCollection'; <ins> import { IMarkdownString } from 'vs/base/common/htmlContent'; </ins> export function isRequestVM(item: unknown): item is IChatRequestViewModel { return !!item && typeof item === 'object' && 'message' in item;


return; } <ins> const next = keybindingService.lookupKeybinding(AccessibleDiffViewerNext.id)?.getAriaLabel(); const previous = keybindingService.lookupKeybinding(AccessibleDiffViewerPrev.id)?.getAriaLabel(); let switchSides; const switchSidesKb = keybindingService.lookupKeybinding('diffEditor.switchSide')?.getAriaLabel(); if (switchSidesKb) { switchSides = localize('msg3', "Run the command Diff Editor: Switch Side ({0}) to toggle between the original and modified editors.", switchSidesKb); } else { switchSides = localize('switchSidesNoKb', "Run the command Diff Editor: Switch Side, which is currently not triggerable via keybinding, to toggle between the original and modified editors."); } </ins> const keys = ['accessibility.signals.diffLineDeleted', 'accessibility.signals.diffLineInserted', 'accessibility.signals.diffLineModified']; const content = [ localize('msg1', "You are in a diff editor."), localize('msg2', "View the next ({0}) or previous ({1}) diff in diff review mode, which is optimized for screen readers.", next, previous), <del> localize('msg3', "To control which accessibility signals should be played, the following settings can be configured: {0}.", keys.join(', ')), </del> <ins> switchSides, localize('msg4', "To control which accessibility signals should be played, the following settings can be configured: {0}.", keys.join(', ')), </ins> ]; const commentCommandInfo = getCommentCommandInfo(keybindingService, contextKeyService, codeEditor); if (commentCommandInfo) {


}); }); <ins> test('trim final new lines bug#46075', function () { const model: TextFileEditorModel = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/trim_final_new_line.txt'), 'utf8'); return model.load().then(() => { const configService = new TestConfigurationService(); configService.setUserConfiguration('files', { 'trimFinalNewlines': true }); const participant = new TrimFinalNewLinesParticipant(configService, undefined); const textContent = 'Test'; const eol = `${model.textEditorModel.getEOL()}`; let content = `${textContent}${eol}${eol}`; model.textEditorModel.setValue(content); // save many times for (let i = 0; i < 10; i++) { participant.participate(model, { reason: SaveReason.EXPLICIT }); } // confirm trimming assert.equal(snapshotToString(model.createSnapshot()), `${textContent}${eol}`); // undo should go back to previous content immediately model.textEditorModel.undo(); assert.equal(snapshotToString(model.createSnapshot()), `${textContent}${eol}${eol}`); model.textEditorModel.redo(); assert.equal(snapshotToString(model.createSnapshot()), `${textContent}${eol}`); }); }); </ins> });


.extension-list-item > .details > .footer > .author > .publisher-name { font-size: 90%; <ins> color: var(--vscode-descriptionForeground); </ins> font-weight: 600; } <ins> .monaco-list-row.disabled .extension-list-item > .details > .footer > .author > .publisher-name{ color: var(--vscode-disabledForeground); } .monaco-list-row.disabled.selected .extension-list-item > .details > .footer > .author > .publisher-name{ color: unset; } .monaco-list-row.selected .extension-list-item > .details > .footer > .author > .publisher-name{ color: unset; } </ins> .extension-list-item > .details > .footer > .author > .publisher-name:not(:first-child) { padding-left: 1px; }


readonly viewType: string; readonly notebook: NotebookTextModel; isDirty(): boolean; <ins> isUntitled(): boolean; </ins> save(): Promise<boolean>; saveAs(target: URI): Promise<boolean>; revert(options?: IRevertOptions | undefined): Promise<void>;


}; export interface ISuggestController { <ins> isPasting: boolean; </ins> selectPreviousSuggestion(): void; selectPreviousPageSuggestion(): void; selectNextSuggestion(): void;


case FormEvent.SENDING: this.isSendingFeedback = true; this.sendButton.setClass('send in-progress'); <del> this.sendButton.value(nls.localize('feedbackSending', "Sending...")); </del> <ins> this.sendButton.value(nls.localize('feedbackSending', "Sending")); </ins> break; case FormEvent.SENT: this.isSendingFeedback = false; <del> this.sendButton.setClass('send success').value(nls.localize('feedbackSent', "Thanks :)")); </del> <ins> this.sendButton.setClass('send success').value(nls.localize('feedbackSent', "Thanks")); </ins> this.resetForm(); this.autoHideTimeout = setTimeout(() => { this.hide();


break; } } <del> if (!differentGroups) { </del> <ins> if (!differentGroups && group.terminalInstances.length === instances.length) { </ins> return; } }


let _commandRegistrations: IDisposable[] = []; <del> ExtensionsRegistry.registerExtensionPoint<schema.IUserFriendlyCommand | schema.IUserFriendlyCommand[]>({ </del> <ins> export const commandsExtensionPoint = ExtensionsRegistry.registerExtensionPoint<schema.IUserFriendlyCommand | schema.IUserFriendlyCommand[]>({ </ins> extensionPoint: 'commands', jsonSchema: schema.commandsContribution <del> }).setHandler(extensions => { </del> <ins> }); commandsExtensionPoint.setHandler(extensions => { </ins> function handleCommand(userFriendlyCommand: schema.IUserFriendlyCommand, extension: IExtensionPointUser<any>, disposables: IDisposable[]) {


@IIntegrityService private readonly integrityService: IIntegrityService, @IWorkbenchEnvironmentService private readonly environmentService: IWorkbenchEnvironmentService, @IAccessibilityService private readonly accessibilityService: IAccessibilityService, <del> @IWorkspaceContextService private readonly contextService: IWorkspaceContextService </del> <ins> @IWorkspaceContextService private readonly contextService: IWorkspaceContextService, @ITextFileService private readonly textFileService: ITextFileService </ins> ) { super();


if (account.canSignOut) { const signOutAction = disposables.add(new Action('signOut', localize('signOut', "Sign Out"), undefined, true, async () => { const allSessions = await this.authenticationService.getSessions(providerId); <del> const sessionsForAccount = allSessions.filter(s => s.account.id === account.id); </del> <ins> const sessionsForAccount = allSessions.filter(s => s.account.label === account.label); </ins> return await this.authenticationService.removeAccountSessions(providerId, account.label, sessionsForAccount); })); providerSubMenuActions.push(signOutAction);


private repositoryPanels: RepositoryPanel[] = []; private singleRepositoryPanelTitleActionsDisposable: IDisposable = EmptyDisposable; private disposables: IDisposable[] = []; <ins> private lastFocusedRepository: ISCMRepository | undefined; </ins> private _onDidSplice = new Emitter<ISpliceEvent<ISCMRepository>>(); readonly onDidSplice: Event<ISpliceEvent<ISCMRepository>> = this._onDidSplice.event;


import { basename, extname } from 'vs/base/common/resources'; import { match } from 'vs/base/common/glob'; import { URI } from 'vs/base/common/uri'; <del> import { Mimes } from 'vs/base/common/mime'; import { getMimeTypes } from 'vs/editor/common/services/languagesAssociations'; </del> import { IModelService } from 'vs/editor/common/services/model'; import { ILanguageService } from 'vs/editor/common/languages/language'; import { IExtensionRecommendationNotificationService, RecommendationsNotificationResult, RecommendationSource } from 'vs/platform/extensionRecommendations/common/extensionRecommendations';


hcLight: '#B5200D' }, localize('activityBarTopActiveFocusBorder', "Focus border color for the active item in the Activity bar when it is on top / bottom. The activity allows to switch between views of the side bar.")); <ins> export const ACTIVITY_BAR_TOP_ACTIVE_BACKGROUND = registerColor('activityBarTop.activeBackground', { dark: null, light: null, hcDark: null, hcLight: null }, localize('activityBarTopActiveBackground', "Background color for the active item in the Activity bar when it is on top / bottom. The activity allows to switch between views of the side bar.")); </ins> export const ACTIVITY_BAR_TOP_INACTIVE_FOREGROUND = registerColor('activityBarTop.inactiveForeground', { dark: transparent(ACTIVITY_BAR_TOP_FOREGROUND, 0.6), light: transparent(ACTIVITY_BAR_TOP_FOREGROUND, 0.75),


<meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src data: ${cspSource}; media-src ${cspSource}; script-src 'nonce-${nonce}'; style-src ${cspSource} 'nonce-${nonce}';"> <meta id="settings" data-settings="${escapeAttribute(JSON.stringify(settings))}">

${vscode.l10n.t("An error occurred while loading the video file.")}


} async getStashes(): Promise<Stash[]> { <del> const result = await this.exec(['stash', 'list']); </del> <ins> const result = await this.exec(['stash', 'list', `--format=${STASH_FORMAT}`, '-z']); </ins> return parseGitStashes(result.stdout.trim()); }


import * as nls from '../../../../nls.js'; import { ICommandHandler } from '../../../../platform/commands/common/commands.js'; import { ServicesAccessor } from '../../../../platform/instantiation/common/instantiation.js'; <del> import { WorkbenchListFocusContextKey } from '../../../../platform/list/browser/listService.js'; </del> <ins> import { WorkbenchCompressibleAsyncDataTree, WorkbenchListFocusContextKey } from '../../../../platform/list/browser/listService.js'; </ins> import { IViewsService } from '../../../services/views/common/viewsService.js'; import { searchClearIcon, searchCollapseAllIcon, searchExpandAllIcon, searchRefreshIcon, searchShowAsList, searchShowAsTree, searchStopIcon } from './searchIcons.js'; import * as Constants from '../common/constants.js'; import { ISearchHistoryService } from '../common/searchHistoryService.js'; <del> import { FileMatch, FolderMatch, FolderMatchNoRoot, FolderMatchWorkspaceRoot, Match, SearchResult, TextSearchResult } from './searchModel.js'; </del> <ins> import { FileMatch, FolderMatch, FolderMatchNoRoot, FolderMatchWorkspaceRoot, Match, RenderableMatch, SearchResult, TextSearchResult } from './searchModel.js'; </ins> import { VIEW_ID } from '../../../services/search/common/search.js'; import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js'; import { Action2, MenuId, registerAction2 } from '../../../../platform/actions/common/actions.js';


dom.EventHelper.stop(e); } })); <del> this.toDispose.push(dom.addDisposableListener(this.selectElement, dom.EventType.KEY_PRESS, (e: KeyboardEvent) => { dom.EventHelper.stop(e); })); </del> } public get onDidSelect(): Event<ISelectData> {


// avoid creating the storage library a second time on // the same DB. <del> const { indededDb: applicationStorageIndexedDB, storage: applicationStorage } = await this.applicationStoragePromise.p; </del> <ins> const { indexedDb: applicationStorageIndexedDB, storage: applicationStorage } = await this.applicationStoragePromise.p; </ins> this.profileStorageDatabase = applicationStorageIndexedDB; this.profileStorage = applicationStorage; <ins> this.profileStorageDisposables.add(this.profileStorage.onDidChangeStorage(key => this.emitDidChangeValue(StorageScope.PROFILE, key))); </ins> } else { const profileStorageIndexedDB = await IndexedDBStorageDatabase.create({ id: this.getId(StorageScope.PROFILE), broadcastChanges: true }, this.logService); this.profileStorageDatabase = this.profileStorageDisposables.add(profileStorageIndexedDB); this.profileStorage = this.profileStorageDisposables.add(new Storage(this.profileStorageDatabase)); <del> } this.profileStorageDisposables.add(this.profileStorage.onDidChangeStorage(key => this.emitDidChangeValue(StorageScope.PROFILE, key))); </del> <ins> this.profileStorageDisposables.add(this.profileStorage.onDidChangeStorage(key => this.emitDidChangeValue(StorageScope.PROFILE, key))); </ins> <del> await this.profileStorage.init(); </del> <ins> await this.profileStorage.init(); </ins> <del> this.updateIsNew(this.profileStorage); </del> <ins> this.updateIsNew(this.profileStorage); } </ins> } private async createWorkspaceStorage(): Promise<void> {


"opn": "^6.0.0", "optimist": "0.3.5", "p-all": "^1.0.0", <del> "playwright": "0.15.0", </del> <ins> "playwright": "1.0.1", </ins> "pump": "^1.0.1", "queue": "3.0.6", "rcedit": "^1.1.0",


} } if (this.extension.enablementState === EnablementState.EnabledGlobally) { <del> this.updateStatus({ message: new MarkdownString(localize('globally enabled', "This extension is enabled globally.")) }, true); </del> return; } }


} /** @type {Promise<void>} */ <del> const workerReady = new Promise(async (resolve, reject) => { </del> <ins> const workerReady = new Promise((resolve, reject) => { </ins> if (!areServiceWorkersEnabled()) { return reject(new Error('Service Workers are not enabled. Webviews will not work. Try disabling private/incognito mode.')); }


suite('NotebookVariableDataSource', () => { let dataSource: NotebookVariableDataSource; const notebookModel = { uri: 'one.ipynb', languages: ['python'] } as unknown as NotebookTextModel; <del> let provideVariablesCalled = false; </del> <ins> let provideVariablesCalled: boolean; </ins> type VariablesResultWithAction = VariablesResult & { action?: () => void }; <del> let results: VariablesResultWithAction[] = [ { id: 1, name: 'a', value: '1', hasNamedChildren: false, indexedChildrenCount: 0 }, ]; </del> <ins> let results: VariablesResultWithAction[]; </ins> const kernel = new class extends mock<INotebookKernel>() { override hasVariableProvider = true;


.extension-list-item > .details { flex: 1; <del> padding: 4px 0; </del> <ins> display: flex; </ins> overflow: hidden; <ins> flex-direction: column; justify-content: center; </ins> } .extension-list-item > .details > .header-container {


moveTo(thisCursor, 3, 9); moveTo(thisCursor, 1, 1, true); moveToEndOfLine(thisCursor, false); <del> assertCursor(thisCursor, new Selection(3, 17, 3, 17)); </del> <ins> assertCursor(thisCursor, new Selection(1, 21, 1, 21)); </ins> }); test('move to end of line with selection single line forward', () => {


} }); } <ins> private _handleCursorPositionChange(e: ICursorPositionChangedEvent | undefined, isModifiedEditor: boolean): void { if (e?.reason === CursorChangeReason.Explicit) { const diff = this._diffModel.get()?.diff.get()?.mappings.find(m => isModifiedEditor ? m.lineRangeMapping.modified.contains(e.position.lineNumber) : m.lineRangeMapping.original.contains(e.position.lineNumber)); if (diff?.lineRangeMapping.modified.isEmpty) { this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineDeleted, { source: 'diffEditor.cursorPositionChanged' }); } else if (diff?.lineRangeMapping.original.isEmpty) { this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineInserted, { source: 'diffEditor.cursorPositionChanged' }); } else if (diff) { this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineModified, { source: 'diffEditor.cursorPositionChanged' }); } } } </ins> } function toLineChanges(state: DiffState): ILineChange[] {


templateData.actionBar.clear(); templateData.icon.style.color = ''; if (resource) { const fileDecorations = this.configurationService.getValue<{ colors: boolean; badges: boolean }>('explorer.decorations'); const labelResource = resource ? resource : URI.parse('missing:_icon_resource');


"entity.name.section" ], "settings": { <del> "fontStyle": "", </del> <ins> "fontStyle": "bold", </ins> "foreground": "#8ab1b0" } },


toggled: { condition: SideBarVisibleContext, title: localize('primary sidebar', "Primary Side Bar"), <del> mnemonicTitle: localize('primary sidebar mnemonic', "&&Primary Side Bar"), </del> <ins> mnemonicTitle: localize({ key: 'primary sidebar mnemonic', comment: ['&& denotes a mnemonic'] }, "&&Primary Side Bar"), </ins> }, category: Categories.View, f1: true,


} } <ins> private resolveKeybindings(actionIds: string[]): TPromise<{ id: string; label: string, isNative: boolean; }[]> { return TPromise.join([this.lifecycleService.when(LifecyclePhase.Running), this.extensionService.whenInstalledExtensionsRegistered()]).then(() => { return arrays.coalesce(actionIds.map(id => { const binding = this.keybindingService.lookupKeybinding(id); if (!binding) { return null; } // first try to resolve a native accelerator const electronAccelerator = binding.getElectronAccelerator(); if (electronAccelerator) { return { id, label: electronAccelerator, isNative: true }; } // we need this fallback to support keybindings that cannot show in electron menus (e.g. chords) const acceleratorLabel = binding.getLabel(); if (acceleratorLabel) { return { id, label: acceleratorLabel, isNative: false }; } return null; })); }); } </ins> private onAddFoldersRequest(request: IAddFoldersRequest): void { // Buffer all pending requests


this._domNode.style.padding = '6px 11px'; this._domNode.style.borderRadius = '2px'; this._domNode.style.cursor = 'pointer'; <ins> this._domNode.style.zIndex = '1'; </ins> if (keyBindingAction) { const keybinding = keybindingService.lookupKeybinding(keyBindingAction);


dispose(deletedCells); }); })); <ins> const vm = this._notebookEditor._getViewModel(); let items: INotebookDeltaCellStatusBarItems[] = []; if (this._enabled) { items = this._getItemsForCells(); } this._cellStatusItems = vm.deltaCellStatusBarItems(this._cellStatusItems, items); } private _getItemsForCells(): INotebookDeltaCellStatusBarItems[] { const items: INotebookDeltaCellStatusBarItems[] = []; for (let i = 0; i < this._notebookEditor.getLength(); i++) { items.push({ handle: i, items: [ <INotebookCellStatusBarItem>{ text: `index: ${i}`, alignment: CellStatusbarAlignment.Left, priority: Number.MAX_SAFE_INTEGER } ] }); } return items; </ins> } override dispose() {


toggled: { condition: AuxiliaryBarVisibleContext, title: localize('secondary sidebar', "Secondary Side Bar"), <del> mnemonicTitle: localize('secondary sidebar mnemonic', "Secondary Si&&de Bar"), </del> <ins> mnemonicTitle: localize({ key: 'secondary sidebar mnemonic', comment: ['&& denotes a mnemonic'] }, "Secondary Si&&de Bar"), </ins> }, category: Categories.View,


buildfile.workerNotebook, buildfile.workerLanguageDetection, buildfile.workerLocalFileSearch, <del> buildfile.workerProfileAnalysis, </del> buildfile.keyboardMaps, buildfile.workbenchWeb ].flat();


let message = localize('extensionEnvironmentContributionInfoStale', "The following extensions want to relaunch the terminal to contribute to its environment:"); message += 'n'; for (const ext of extSet) { <del> message += `n- `${ext}``; </del> <ins> message += `n- `${getExtensionName(ext, this._extensionService)}``; </ins> } return message; }


type ManualSyncTaskEvent<T> = { manualSyncTaskId: string; data: T }; <del> function reviewSyncResource(syncResource: IUserDataSyncResource, userDataProfilesService: IUserDataProfilesService) { return { ...syncResource, profie: reviveProfile(syncResource.profile, userDataProfilesService.profilesHome.scheme) }; </del> <ins> function reviewSyncResource(syncResource: IUserDataSyncResource, userDataProfilesService: IUserDataProfilesService): IUserDataSyncResource { return { ...syncResource, profile: reviveProfile(syncResource.profile, userDataProfilesService.profilesHome.scheme) }; </ins> } export class UserDataSyncChannel implements IServerChannel {


executableEnv, windowsEnableConpty }; <del> const persistentProcess = new PersistentTerminalProcess(id, process, workspaceId, workspaceName, shouldPersist, cols, rows, processLaunchOptions, unicodeVersion, this._reconnectConstants, this._logService, isReviving ? shellLaunchConfig.initialText : undefined, shellLaunchConfig.icon, shellLaunchConfig.color, shellLaunchConfig.fixedDimensions); </del> <ins> const persistentProcess = new PersistentTerminalProcess(id, process, workspaceId, workspaceName, shouldPersist, cols, rows, processLaunchOptions, unicodeVersion, this._reconnectConstants, this._logService, isReviving ? shellLaunchConfig.initialText : undefined, shellLaunchConfig.icon, shellLaunchConfig.color, shellLaunchConfig.name, shellLaunchConfig.fixedDimensions); </ins> process.onDidChangeProperty(property => this._onDidChangeProperty.fire({ id, property })); process.onProcessExit(event => { persistentProcess.dispose();


<del> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ function numberHash(val: number, initialHashVal: number): number { return (((initialHashVal << 5) - initialHashVal) + val) | 0;  // hashVal * 31 + ch, keep as int32 } export function stringHash(s: string) { let hashVal = numberHash(149417, 0); for (let i = 0, length = s.length; i < length; i++) { hashVal = numberHash(s.charCodeAt(i), hashVal); } return hashVal; } </del>


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ import { Lazy } from 'vs/base/common/lazy'; /** * A regex that extracts the link suffix which contains line and column information. */ const linkSuffixRegex = new Lazy<RegExp>(() => { let ri = 0; let ci = 0; function l(): string { return `(?<row${ri++}>d+)`; } function c(): string { return `(?<col${ci++}>d+)`; } // The comments in the regex below use real strings/numbers for better readability, here's // the legend: // - Path = foo // - Row  = 339 // - Col  = 12 // // These all support single quote ' in the place of " and [] in the place of () const lineAndColumnRegexClauses = [ // foo:339 // foo:339:12 // foo 339 // foo 339:12                   [#140780] // "foo",339 // "foo",339:12 `(?::| |['"],)${l()}(:${c()})?$`, // "foo", line 339               [#40468] // "foo", line 339, col 12 // "foo", line 339, column 12 // "foo":line 339 // "foo":line 339, col 12 // "foo":line 339, column 12 // "foo": line 339 // "foo": line 339, col 12 // "foo": line 339, column 12 // "foo" on line 339 // "foo" on line 339, col 12 // "foo" on line 339, column 12 `['"](?:, |: ?| on )line ${l()}(, col(?:umn)? ${c()})?$`, // foo(339) // foo(339,12) // foo(339, 12) // foo (339) // foo (339,12) // foo (339, 12) ` ?[[(]${l()}(?:, ?${c()})?[])]`, ]; const suffixClause = lineAndColumnRegexClauses // Join all clauses together .join('|') // Convert spaces to allow the non-breaking space char (ascii 160) .replace(/ /g, `[${'u00A0'} ]`); return new RegExp(`(${suffixClause})`); }); /** * Removes the optional link suffix which contains line and column information. * @param link The link to parse. */ export function removeLinkSuffix(link: string): string { const suffix = getLinkSuffix(link)?.suffix; if (!suffix) { return link; } return link.substring(0, suffix.index); } /** * Returns the optional link suffix which contains line and column information. * @param link The link to parse. */ export function getLinkSuffix(link: string): { row: number | undefined; col: number | undefined; suffix: { index: number; text: string } } | null { const matches = linkSuffixRegex.getValue().exec(link); const groups = matches?.groups; if (!groups || matches.length < 1) { return null; } const rowString = groups.row0 || groups.row1 || groups.row2; const colString = groups.col0 || groups.col1 || groups.col2; return { row: rowString !== undefined ? parseInt(rowString) : undefined, col: colString !== undefined ? parseInt(colString) : undefined, suffix: { index: matches.index, text: matches[0] } }; } </ins>


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


*--------------------------------------------------------------------------------------------*/ import { OperatingSystem, OS } from 'vs/base/common/platform'; <ins> import type { IShellLaunchConfig } from 'vs/platform/terminal/common/terminal'; </ins> /** * Aggressively escape non-windows paths to prepare for being sent to a shell. This will do some


private readonly _onDidStateChange: Emitter<ITaskEvent>; <ins> get taskShellIntegrationStartSequence(): string { return this._configurationService.getValue('task.showDecorations') ? VSCodeSequence(VSCodeOscPt.PromptStart) + VSCodeSequence(VSCodeOscPt.Property, `${VSCodeOscProperty.Task}=True`) + VSCodeSequence(VSCodeOscPt.CommandStart) : ''; } get taskShellIntegrationOutputSequence(): string { return this._configurationService.getValue('task.showDecorations') ? VSCodeSequence(VSCodeOscPt.CommandExecuted) : ''; } </ins> constructor( private _terminalService: ITerminalService, private _terminalGroupService: ITerminalGroupService,


} export class MoveToMatchFindAction extends EditorAction { <ins> private _highlightDecorations: string[] = []; </ins> constructor() { super({ id: FIND_IDS.GoToMatchFindAction,


} })); this._sessionDisposables.add(this._editor.onDidChangeModelContent((e) => { <ins> cts?.cancel(); </ins> // update less aggressive when typing const delay = Math.max(scheduler.delay, 1250); scheduler.schedule(delay);


if (!language || !locale || locale === 'en' || locale.indexOf('en-') === 0) { return; } <del> if (language === locale || languagePackSuggestionIgnoreList.indexOf(language) > -1) { </del> <ins> if (language === locale || languagePackSuggestionIgnoreList.indexOf(locale) > -1) { </ins> return; }


return this.configurationService.getValue(LayoutSettings.ACTIVITY_BAR_LOCATION) !== ActivityBarPosition.HIDDEN; } <ins> private rememberActivityBarVisiblePosition(): void { const activityBarPosition = this.configurationService.getValue<string>(LayoutSettings.ACTIVITY_BAR_LOCATION); if (activityBarPosition !== ActivityBarPosition.HIDDEN) { this.storageService.store(LayoutSettings.ACTIVITY_BAR_LOCATION, activityBarPosition, StorageScope.PROFILE, StorageTarget.USER); } } private getRememberedActivityBarVisiblePosition(): ActivityBarPosition { const activityBarPosition = this.storageService.get(LayoutSettings.ACTIVITY_BAR_LOCATION, StorageScope.PROFILE); switch (activityBarPosition) { case ActivityBarPosition.SIDE: return ActivityBarPosition.SIDE; default: return ActivityBarPosition.TOP; } } </ins> private updateActivityBarVisiblity(): void { if (this.shouldShowActivityBar()) { this.acitivityBarPart.show();


extensionWorkbenchService.open(extension, { showPreReleaseVersion: false }); } }); <ins> this.registerExtensionAction({ id: SkipUpdateAction.ID, title: { value: SkipUpdateAction.LABEL, original: 'Ignore Updates' }, category: ExtensionsLocalizedLabel, toggled: ContextKeyDefinedExpr.create('isExtensionPinned'), menu: { id: MenuId.ExtensionContext, group: INSTALL_ACTIONS_GROUP, order: 2, when: ContextKeyExpr.and(ContextKeyExpr.equals('extensionStatus', 'installed'), ContextKeyExpr.not('isBuiltinExtension')) }, run: async (accessor: ServicesAccessor, id: string) => { const instantiationService = accessor.get(IInstantiationService); const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService); const extension = extensionWorkbenchService.local.find(e => areSameExtensions(e.identifier, { id })); if (extension) { const action = instantiationService.createInstance(SkipUpdateAction); action.extension = extension; return action.run(); } } }); </ins> this.registerExtensionAction({ id: SwitchToPreReleaseVersionAction.ID, title: SwitchToPreReleaseVersionAction.TITLE,


id: MenuId.NotebookCellTitle, when: NOTEBOOK_EDITOR_FOCUSED, group: CellOverflowToolbarGroups.Copy, <ins> order: 2, </ins> }, keybinding: platform.isNative ? undefined : { primary: KeyMod.CtrlCmd | KeyCode.KeyC,


keybinding: { weight: KeybindingWeight.WorkbenchContrib, primary: KeyMod.CtrlCmd | KeyCode.DownArrow, <ins> when: CONTEXT_IN_CHAT_INPUT </ins> } }); }


stats?: IFileSearchProviderStats; } <ins> /** * For backwards compatibility, store both a cancellation token and a session object. The session object is the new implementation, where */ class SessionLifecycle extends Disposable { public readonly obj: object; public readonly tokenSource: CancellationTokenSource; constructor() { super(); this.obj = new Object(); this.tokenSource = new CancellationTokenSource(); } public override dispose(): void { this.tokenSource.cancel(); super.dispose(); } } </ins> export class FileSearchManager { private static readonly BATCH_SIZE = 512; <del> private readonly sessions = new Map<string, unknown>(); </del> <ins> private readonly sessions = new Map<string, SessionLifecycle>(); </ins> fileSearch(config: IFileQuery, provider: FileSearchProviderNew, onBatch: (matches: IFileMatch[]) => void, token: CancellationToken): Promise<ISearchCompleteStats> { const sessionTokenSource = this.getSessionTokenSource(config.cacheKey);


dependencies: object-keys "~0.4.0" <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"


scope: scopeData.scopeStr, sessionId, account: { <del> label, </del> <ins> label: claims.email ?? claims.preferred_username ?? claims.unique_name ?? 'user@example.com', </ins> id, type: claims.tid === MSA_TID || claims.tid === MSA_PASSTHRU_TID ? MicrosoftAccountType.MSA : MicrosoftAccountType.AAD }


console.error(`Playwright ERROR: HTTP status ${response.status()} for ${response.url()}`); } }); <ins> page.on('console', async msg => { try { consoleLogFn(msg)(msg.text(), await Promise.all(msg.args().map(async arg => await arg.jsonValue()))); } catch (err) { console.error('Error logging console', err); } }); page.on('requestfailed', e => { console.error('Request Failed', e.url(), e.failure()?.errorText); }); </ins> const host = endpoint.host; const protocol = 'vscode-remote';


return filename; } <del> // Trim whitespaces filename = strings.trim(strings.trim(filename, ' '), 't'); </del> <ins> // Trim tabs filename = strings.trim(filename, 't'); </ins> <del> // Remove trailing dots </del> <ins> // Remove trailing dots, slashes, and spaces </ins> filename = strings.rtrim(filename, '.'); <del> // Remove trailing slashes </del> <ins> filename = strings.rtrim(filename, ' '); </ins> filename = strings.rtrim(filename, '/'); filename = strings.rtrim(filename, '');


if (!model) { return; } <del> const selection = this._editor.getSelection(); if (!selection.isEmpty()) { return; } const position = selection.getStartPosition(); </del> <ins> let newSelections: Selection[] = []; this._editor.getSelections().forEach(selection => { const position = selection.getStartPosition(); </ins> <del> let brackets = model.matchBracket(position); </del> <ins> let brackets = model.matchBracket(position); </ins> <del> let openBracket: Position = null; let closeBracket: Position = null; </del> <ins> let openBracket: Position = null; let closeBracket: Position = null; </ins> <del> if (!brackets) { const nextBracket = model.findNextBracket(position); if (nextBracket && nextBracket.range) { brackets = model.matchBracket(nextBracket.range.getStartPosition()); </del> <ins> if (!brackets) { const nextBracket = model.findNextBracket(position); if (nextBracket && nextBracket.range) { brackets = model.matchBracket(nextBracket.range.getStartPosition()); } </ins> } <del> } if (brackets) { if (brackets[0].startLineNumber === brackets[1].startLineNumber) { openBracket = brackets[1].startColumn < brackets[0].startColumn ? brackets[1].getStartPosition() : brackets[0].getStartPosition(); closeBracket = brackets[1].startColumn < brackets[0].startColumn ? brackets[0].getEndPosition() : brackets[1].getEndPosition(); } else { openBracket = brackets[1].startLineNumber < brackets[0].startLineNumber ? brackets[1].getStartPosition() : brackets[0].getStartPosition(); closeBracket = brackets[1].startLineNumber < brackets[0].startLineNumber ? brackets[0].getEndPosition() : brackets[1].getEndPosition(); </del> <ins> if (brackets) { if (brackets[0].startLineNumber === brackets[1].startLineNumber) { openBracket = brackets[1].startColumn < brackets[0].startColumn ? brackets[1].getStartPosition() : brackets[0].getStartPosition(); closeBracket = brackets[1].startColumn < brackets[0].startColumn ? brackets[0].getEndPosition() : brackets[1].getEndPosition(); } else { openBracket = brackets[1].startLineNumber < brackets[0].startLineNumber ? brackets[1].getStartPosition() : brackets[0].getStartPosition(); closeBracket = brackets[1].startLineNumber < brackets[0].startLineNumber ? brackets[0].getEndPosition() : brackets[1].getEndPosition(); } </ins> } <del> } if (openBracket && closeBracket) { this._editor.setSelection(new Range(openBracket.lineNumber, openBracket.column, closeBracket.lineNumber, closeBracket.column)); </del> <ins> if (openBracket && closeBracket) { newSelections.push(new Selection(openBracket.lineNumber, openBracket.column, closeBracket.lineNumber, closeBracket.column)); } }); if (newSelections.length > 0) { this._editor.setSelections(newSelections); this._editor.revealRange(newSelections[0]); </ins> } }


this._terminalCreationQueue = this._terminalCreationQueue.then(() => this._doCreateTerminal(task, group, launchConfigs!)); const terminal: ITerminalInstance = (await this._terminalCreationQueue)!; <del> terminal.shellLaunchConfig.reconnectionProperties = { ownerId: ReconnectionType, data: { lastTask: task.getCommonTaskId(), group, label: task._label, id: task._id } }; </del> <ins> if (task.configurationProperties.isBackground) { terminal.shellLaunchConfig.reconnectionProperties = { ownerId: ReconnectionType, data: { lastTask: task.getCommonTaskId(), group, label: task._label, id: task._id } }; } </ins> const terminalKey = terminal.instanceId.toString(); const terminalData = { terminal: terminal, lastTask: taskKey, group }; terminal.onDisposed(() => this._deleteTaskAndTerminal(terminal, terminalData));


group: '', title: nls.localize('actions.clipboard.copyLabel', "Copy"), order: 1 <ins> }, { menuId: MenuId.SimpleEditorContext, group: CLIPBOARD_CONTEXT_MENU_GROUP, title: nls.localize('actions.clipboard.copyLabel', "Copy"), order: 2, </ins> }] })) : undefined;


/** * Inline hints */ <del> export const editorInlayHintForeground = registerColor('editorInlayHint.foreground', { dark: transparent(badgeForeground, .8), light: transparent(badgeForeground, .8), hcDark: badgeForeground, hcLight: badgeForeground }, nls.localize('editorInlayHintForeground', 'Foreground color of inline hints')); export const editorInlayHintBackground = registerColor('editorInlayHint.background', { dark: transparent(badgeBackground, .6), light: transparent(badgeBackground, .3), hcDark: badgeBackground, hcLight: badgeBackground }, nls.localize('editorInlayHintBackground', 'Background color of inline hints')); </del> <ins> export const editorInlayHintForeground = registerColor('editorInlayHint.foreground', { dark: badgeForeground, light: badgeForeground, hcDark: Color.black, hcLight: badgeForeground }, nls.localize('editorInlayHintForeground', 'Foreground color of inline hints')); export const editorInlayHintBackground = registerColor('editorInlayHint.background', { dark: transparent(badgeBackground, .8), light: transparent(badgeBackground, .6), hcDark: '#f38518', hcLight: badgeBackground }, nls.localize('editorInlayHintBackground', 'Background color of inline hints')); </ins> export const editorInlayHintTypeForeground = registerColor('editorInlayHint.typeForeground', { dark: editorInlayHintForeground, light: editorInlayHintForeground, hcDark: editorInlayHintForeground, hcLight: editorInlayHintForeground }, nls.localize('editorInlayHintForegroundTypes', 'Foreground color of inline hints for types')); export const editorInlayHintTypeBackground = registerColor('editorInlayHint.typeBackground', { dark: editorInlayHintBackground, light: editorInlayHintBackground, hcDark: editorInlayHintBackground, hcLight: editorInlayHintBackground }, nls.localize('editorInlayHintBackgroundTypes', 'Background color of inline hints for types')); export const editorInlayHintParameterForeground = registerColor('editorInlayHint.parameterForeground', { dark: editorInlayHintForeground, light: editorInlayHintForeground, hcDark: editorInlayHintForeground, hcLight: editorInlayHintForeground }, nls.localize('editorInlayHintForegroundParameter', 'Foreground color of inline hints for parameters'));


private getMarkersItemTurnedOff(): IStatusbarEntry { const config = this.configurationService.getValue('problems.visibility'); <del> if (config) { return { name: '', text: '', ariaLabel: '', tooltip: '', command: '' }; } </del> <ins> this.statusbarService.updateEntryVisibility('status.problemsVisibility', !config); </ins> const openSettingsCommand = 'workbench.action.openSettings'; <del> const configureSettingsLabel = 'problems.visibility'; </del> <ins> const configureSettingsLabel = '@id:problems.visibility'; </ins> const tooltip = !config ? localize('problemsOff', "Problems have been turned off.") : ''; return { <del> name: localize('status.problems.off', "Problems"), </del> <ins> name: localize('status.problemsVisibility', "Problems Visibility"), </ins> text: '$(whole-word)', ariaLabel: tooltip, tooltip,


} public validate(): boolean { <del> let result: IMessage = null; </del> <ins> let errorMsg: IMessage = null; </ins> if (this.validation) { <del> result = this.validation(this.value); </del> <ins> errorMsg = this.validation(this.value); </ins> <del> if (!result) { </del> <ins> if (errorMsg) { this.inputElement.setAttribute('aria-invalid', 'true'); this.showMessage(errorMsg); } else if (this.inputElement.hasAttribute('aria-invalid')) { </ins> this.inputElement.removeAttribute('aria-invalid'); this.hideMessage(); <del> } else { this.inputElement.setAttribute('aria-invalid', 'true'); this.showMessage(result); </del> } } <del> return !result; </del> <ins> return !errorMsg; </ins> } private stylesForType(type: MessageType): { border: Color; background: Color } {


if (Range.isIRange((obj as modes.Location).range) && URI.isUri((obj as modes.Location).uri)) { return extHostTypeConverter.location.to(obj); } <ins> if (obj instanceof VSBuffer) { return obj.buffer.buffer; } </ins> if (!Array.isArray(obj)) { return obj; }


const apiProposalNotListed = l10n.t("This proposal cannot be used because for this extension the product defines a fixed set of API proposals. You can test your extension but before publishing you MUST reach out to the VS Code team."); const implicitActivationEvent = l10n.t("This activation event cannot be explicitly listed by your extension."); const redundantImplicitActivationEvent = l10n.t("This activation event can be removed as VS Code generates these automatically from your package.json contribution declarations."); <ins> const starActivation = l10n.t("Using '*' activation is usually a bad idea as it impacts performance."); </ins> enum Context { ICON,


} } const pickOptions: IPickOptions<PickStringItem> = { placeHolder: info.description, matchOnDetail: true, ignoreFocusLost: true }; <del> return this.quickInputService.pick(picks, pickOptions, undefined).then(resolvedInput => { </del> <ins> return this.userInputAccessQueue.queue(() => this.quickInputService.pick(picks, pickOptions, undefined)).then(resolvedInput => { </ins> if (resolvedInput) { <del> return resolvedInput.value; </del> <ins> return (resolvedInput as PickStringItem).value; </ins> } return undefined; });


this.continueEditSessionOptions = continueEditSessionOptions; }); <ins> this.shouldShowViewsContext = EDIT_SESSIONS_SHOW_VIEW.bindTo(this.contextKeyService); </ins> textModelResolverService.registerTextModelContentProvider(EDIT_SESSIONS_SCHEME, instantiationService.createInstance(EditSessionsContentProvider)); }


leftMarginRatio: this.centeredEditorLeftMarginRatio, size: this.centeredEditorSize }; <del> this.storageServise.store(EditorGroupsControl.CENTERED_EDITOR_LAYOUT_DATA_STORAGE_KEY, JSON.stringify(data), StorageScope.GLOBAL); </del> <ins> this.storageService.store(EditorGroupsControl.CENTERED_EDITOR_LAYOUT_DATA_STORAGE_KEY, JSON.stringify(data), StorageScope.GLOBAL); </ins> } public getVerticalSashTop(sash: Sash): number {


description: nls.localize('task.quickOpen.showAll', "Causes the Tasks: Run Task command to use the slower "show all" behavior instead of the faster two level picker where tasks are grouped by provider."), default: false }, <ins> 'task.showDecorations': { type: 'boolean', description: nls.localize('task.showDecorations', "Shows decorations at points of interest in the terminal buffer such as the first problem found via a watch task. Note that this will only take effect for future tasks."), default: true }, </ins> 'task.saveBeforeRun': { markdownDescription: nls.localize( 'task.saveBeforeRun',


media: { type: 'markdown', path: 'empty' } <ins> }, { id: 'accessibilitySettings', title: localize('gettingStarted.accessibilitySettings.title', "Configure accessibility settings"), description: localize('gettingStarted.accessibilitySettings.description.interpolated', "Accessibility settings can be configured by running the Open Accessibility Settings command.n{0}", Button(localize('openAccessibilitySettings', "Open Accessibility Settings"), 'command:workbench.action.openAccessibilitySettings')), media: { type: 'markdown', path: 'empty' } </ins> } ] }


if (Object.keys(matchedRecommendations).length) { this.promptFromRecommendations(uri, model, matchedRecommendations); <del> return true; </del> } <del> return false; </del> } private promptFromRecommendations(uri: URI, model: ITextModel, extensionRecommendations: IStringDictionary<IFileOpenCondition[]>): void {


// Stat needs to be resolved first and then revealed const options: IResolveFileOptions = { resolveTo: [resource], resolveMetadata: this.sortOrder === 'modified' }; const workspaceFolder = this.contextService.getWorkspaceFolder(resource); <del> const rootUri = workspaceFolder ? workspaceFolder.uri : this.roots[0].resource; </del> <ins> if (workspaceFolder === null) { return Promise.resolve(undefined); } const rootUri = workspaceFolder.uri; </ins> const root = this.roots.filter(r => r.resource.toString() === rootUri.toString()).pop()!; try {


const toplevelDomainSegements = parsedDomainToConfigure.authority.split('.'); const domainEnd = toplevelDomainSegements.slice(toplevelDomainSegements.length - 2).join('.'); const topLevelDomain = '*.' + domainEnd; <ins> const options: ConfigureTrustedDomainsQuickPickItem[] = []; </ins> <del> const trustDomainAndOpenLinkItem: ConfigureTrustedDomainsQuickPickItem = { </del> <ins> options.push({ </ins> type: 'item', label: localize('trustedDomain.trustDomain', 'Trust {0}', domainToConfigure), <del> id: 'trustDomain', </del> <ins> id: 'trust', toTrust: domainToConfigure, </ins> picked: true <del> }; const trustSubDomainAndOpenLinkItem: ConfigureTrustedDomainsQuickPickItem = { type: 'item', label: localize('trustedDomain.trustSubDomain', 'Trust {0} and all its subdomains', domainEnd), id: 'trustSubdomain' }; const openAllLinksItem: ConfigureTrustedDomainsQuickPickItem = { </del> <ins> }); const isIP = toplevelDomainSegements.length === 4 && toplevelDomainSegements.every(segment => Number.isInteger(+segment) || Number.isInteger(+segment.split(':')[0])); if (isIP) { if (parsedDomainToConfigure.authority.includes(':')) { const base = parsedDomainToConfigure.authority.split(':')[0]; options.push({ type: 'item', label: localize('trustedDomain.trustAllPorts', 'Trust {0} on all ports', base), toTrust: base + ':*', id: 'trust' }); } } else { options.push({ type: 'item', label: localize('trustedDomain.trustSubDomain', 'Trust {0} and all its subdomains', domainEnd), toTrust: topLevelDomain, id: 'trust' }); } options.push({ </ins> type: 'item', label: localize('trustedDomain.trustAllDomains', 'Trust all domains (disables link protection)'), <del> id: 'trustAll' }; const manageTrustedDomainItem: ConfigureTrustedDomainsQuickPickItem = { </del> <ins> toTrust: '*', id: 'trust' }); options.push({ </ins> type: 'item', label: localize('trustedDomain.manageTrustedDomains', 'Manage Trusted Domains'), id: 'manage' <del> }; </del> <ins> }); </ins> const pickedResult = await quickInputService.pick<ConfigureTrustedDomainsQuickPickItem>( <del> [trustDomainAndOpenLinkItem, trustSubDomainAndOpenLinkItem, openAllLinksItem, manageTrustedDomainItem], { activeItem: trustDomainAndOpenLinkItem } </del> <ins> options, { activeItem: options[0] } </ins> ); if (pickedResult && pickedResult.id) {


return extHostTypeConverter.location.from(value); } else if (extHostTypes.NotebookRange.isNotebookRange(value)) { return extHostTypeConverter.NotebookRange.from(value); <ins> } else if (value instanceof ArrayBuffer) { hasBuffers = true; return VSBuffer.wrap(new Uint8Array(value)); } else if (value instanceof Uint8Array) { hasBuffers = true; return VSBuffer.wrap(value); </ins> } if (!Array.isArray(value)) { return value;


// Terminal shell integration 'out-build/vs/workbench/contrib/terminal/browser/media/shellIntegration.ps1', 'out-build/vs/workbench/contrib/terminal/browser/media/shellIntegration-bash.sh', <ins> 'out-build/vs/workbench/contrib/terminal/browser/media/shellIntegration-env.zsh', 'out-build/vs/workbench/contrib/terminal/browser/media/shellIntegration-profile.zsh', </ins> 'out-build/vs/workbench/contrib/terminal/browser/media/shellIntegration.zsh', '!**/test/**'


"inputOption.activeBorder": "#2488DB", "keybindingLabel.foreground": "#CCCCCC", "menu.background": "#1F1F1F", <ins> "menu.selectionBackground": "#0078d4", </ins> "notificationCenterHeader.background": "#1F1F1F", "notificationCenterHeader.foreground": "#CCCCCC", "notifications.background": "#1F1F1F",


let prefixFileRegex = RegExp('(d+)(' + separators + '.*)(..*)$'); if (!isFolder && name.match(prefixFileRegex)) { return name.replace(prefixFileRegex, (match, g1?, g2?, g3?) => { <del> return strings.pad(parseInt(g1) + 1, g1.length) + g2 + g3; </del> <ins> let number = parseInt(g1); return number < maxNumber ? strings.pad(number + 1, g1.length) + g2 + g3 : strings.format('{0}{1}.1{2}', g1, g2, g3); </ins> }); }


[ localize('openExternalDialogButtonRetry', "Try again"), localize('openExternalDialogButtonInstall', "Install {0}", this.productService.nameLong), <del> localize('openExternalDialogButtonContinue', "Continue here") </del> <ins> localize('openExternalDialogButtonCancel', "Cancel") </ins> ], { cancelId: 2, <del> detail: localize('openExternalDialogDetail', "We tried opening {0} on your computer.", this.productService.nameLong) </del> <ins> 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, ) </ins> }, );


this._terminalHasTextContextKey.set(isActive && this.hasSelection()); } <del> private _sanitizeInput(data: any) { return typeof data === 'string' ? data.replace(TerminalInstance.WINDOWS_EOL_REGEX, 'r') : data; } </del> protected _getCwd(shell: IShellLaunchConfig, root: Uri): string { if (shell.cwd) { return shell.cwd;


resolved "https://registry.yarnpkg.com/xterm-addon-unicode11/-/xterm-addon-unicode11-0.5.0.tgz#41c0d96acc1e3bb6c6596eee64e163b6bca74be7" integrity sha512-Jm4/g4QiTxiKiTbYICQgC791ubhIZyoIwxAIgOW8z8HWFNY+lwk+dwaKEaEeGBfM48Vk8fklsUW9u/PlenYEBg== <del> xterm-addon-webgl@0.15.0-beta.7: version "0.15.0-beta.7" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.15.0-beta.7.tgz#ab247b499f61e8eebff92e08ec5ca999d87e06af" integrity sha512-7WCI/D6uFNp3y9TeTsbSo1h7gCy4h/yP2lWn8ZEjCaiGvO11DbKMq17fbiwaR3YmGWXoRKkcLaNIiqxFnjKO4w== </del> <ins> xterm-addon-webgl@0.15.0-beta.8: version "0.15.0-beta.8" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.15.0-beta.8.tgz#2005198582f6f1f4a9b2612b9354c0bcc9f148d8" integrity sha512-HjTr9bi3FvdOIPaaIpih6qdHX2z+H7sQPluLj5KzwCqRiEVUVRi19dl8SdHjf6dCmN3GahMhjV7D+zxHi2pLTw== </ins> <del> xterm@5.2.0-beta.30: version "5.2.0-beta.30" resolved "https://registry.yarnpkg.com/xterm/-/xterm-5.2.0-beta.30.tgz#6f50796d1652a61b30eeed7fa2bdd9c485a7d8ee" integrity sha512-l1YBwMnakKXd638oxbzEg9Y1sWqxcrm/q7i5gBuWaK8N7Tq1NvF51FCamxXtfdL4dostgw8WoM+/6KRlL53t6A== </del> <ins> xterm@5.2.0-beta.33: version "5.2.0-beta.33" resolved "https://registry.yarnpkg.com/xterm/-/xterm-5.2.0-beta.33.tgz#584fb261ec283573ddb9d3ef4b3ea63a9a359f81" integrity sha512-HIkQgn0/akWLWLzUJquAeVF1/nqPgqL6KzmhkAOJbOtNHftNZbEK+lDGfzz1dUC/smpXQkKm7X2nn92h3i1tgQ== </ins>


import { WorkbenchStateContext } from 'vs/workbench/common/contextkeys'; import { OpenFolderAction, OpenFileAction, OpenFileFolderAction } from 'vs/workbench/browser/actions/workspaceActions'; import { isMacintosh, isWeb } from 'vs/base/common/platform'; <del> import { isCodeEditor } from 'vs/editor/browser/editorBrowser'; </del> <ins> import { isCodeEditor, isDiffEditor } from 'vs/editor/browser/editorBrowser'; </ins> import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage'; import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; import { DisposableStore } from 'vs/base/common/lifecycle';


} if (node.collapsible) { <del> // Do not set this before calling a handler on the super class, because it will reject it as handled e.browserEvent.isHandledByList = true; </del> const location = this.tree.getNodeLocation(node); const recursive = e.browserEvent.altKey; this.tree.setFocus([location]); this.tree.toggleCollapsed(location, recursive); if (expandOnlyOnTwistieClick && onTwistie) { <ins> // Do not set this before calling a handler on the super class, because it will reject it as handled e.browserEvent.isHandledByList = true; </ins> return; } }


case MarkdownPreviewSecurityLevel.AllowInsecureContent: return `<meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src vscode-resource: http: https: data:; media-src vscode-resource: http: https: data:; script-src 'nonce-${nonce}'; style-src vscode-resource: 'unsafe-inline' http: https: data:; font-src vscode-resource: http: https: data:;">`; <ins> case MarkdownPreviewSecurityLevel.AllowInsecureLocalContent: return `<meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src vscode-resource: https: data: http://localhost:* http://127.0.0.1:*; media-src vscode-resource: https: data: http://localhost:* http://127.0.0.1:*; script-src 'nonce-${nonce}'; style-src vscode-resource: 'unsafe-inline' https: data: http://localhost:* http://127.0.0.1:*; font-src vscode-resource: https: data: http://localhost:* http://127.0.0.1:*;">`; </ins> case MarkdownPreviewSecurityLevel.AllowScriptsAndAllContent: return '';


// Listen to editor closing (if we run with --wait) const filesToWait = this.environmentService.configuration.filesToWait; if (filesToWait) { <del> const resourcesToWaitFor = coalesce(filesToWait.paths.map(p => p.fileUri)); </del> const waitMarkerFile = filesToWait.waitMarkerFileUri; <del> const listenerDispose = this.editorService.onDidCloseEditor(() => this.onEditorClosed(listenerDispose, resourcesToWaitFor, waitMarkerFile)); </del> <ins> const resourcesToWaitFor = coalesce(filesToWait.paths.map(p => p.fileUri)); </ins> <del> this._register(listenerDispose); </del> <ins> this._register(this.trackClosedWaitFiles(waitMarkerFile, resourcesToWaitFor)); </ins> } }


// service worker already loaded & ready to receive messages postVersionMessage(currentController); } else { <del> console.log(`Found unexpected service worker controller. Found: ${currentController?.scriptURL}. Expected: ${swPath}`); </del> <ins> if (currentController) { console.log(`Found unexpected service worker controller. Found: ${currentController.scriptURL}. Expected: ${swPath}. Waiting for controllerchange.`); } else { console.log(`No service worker controller found. Waiting for controllerchange.`); } </ins> <del> // either there's no controlling service worker, or it's an old one: // wait for it to change before posting the message </del> <ins> // Either there's no controlling service worker, or it's an old one. // Wait for it to change before posting the message </ins> const onControllerChange = () => { navigator.serviceWorker.removeEventListener('controllerchange', onControllerChange); <del> postVersionMessage(navigator.serviceWorker.controller); </del> <ins> if (navigator.serviceWorker.controller) { postVersionMessage(navigator.serviceWorker.controller); } else { return reject(new Error('No controller found.')); } </ins> }; navigator.serviceWorker.addEventListener('controllerchange', onControllerChange); }


} const controller = editor.getContribution<TroubleshootController>(TroubleshootController.id); <del> controller?.toggleLogging(); </del> <ins> controller?.toggle(); </ins> } });


'force'?: boolean; 'force-user-env'?: boolean; <del> // node flags </del> <ins> // chromium command line args: https://electronjs.org/docs/all#supported-chrome-command-line-switches 'no-proxy-server'?: boolean; 'proxy-server'?: string; 'proxy-bypass-list'?: string; 'proxy-pac-url'?: string; 'inspect'?: string; 'inspect-brk'?: string; </ins> 'js-flags'?: string; 'disable-gpu'?: boolean; 'nolazy'?: boolean;


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


} } <del> export class ExtensionsTree extends WorkbenchAsyncDataTree<IExtensionData, any> { </del> <ins> export class ExtensionsTree extends WorkbenchAsyncDataTree<IExtensionData, IExtensionData> { </ins> constructor( input: IExtensionData,


import * as aria from 'vs/base/browser/ui/aria/aria'; import { Action, IAction } from 'vs/base/common/actions'; import { distinct } from 'vs/base/common/arrays'; <del> import { Queue, raceTimeout, RunOnceScheduler } from 'vs/base/common/async'; </del> <ins> import { raceTimeout, RunOnceScheduler } from 'vs/base/common/async'; </ins> import { CancellationTokenSource } from 'vs/base/common/cancellation'; import { isErrorWithActions } from 'vs/base/common/errorMessage'; import * as errors from 'vs/base/common/errors';


@memoize get onDidChangeSelection() { return Event.map( <del> this._tree.onDidChangeSelection, </del> <ins> Event.any(this._tree.onDidChangeSelection, this._onTriggerEmptySelectionOrFocus.event), </ins> e => ({ items: e.elements.filter((e): e is QuickPickItemElement => e instanceof QuickPickItemElement).map(e => e.item), event: e.browserEvent


const onEnablementChange = filterEvent(workspace.onDidChangeConfiguration, e => e.affectsConfiguration('git.enableStatusBarSync')); onEnablementChange(this.updateEnablement, this, this.disposables); <ins> this.updateEnablement(); </ins> this._onDidChange.fire(); }


import type * as nbformat from '@jupyterlab/nbformat'; import { NotebookCell, NotebookCellData, NotebookCellKind, NotebookCellOutput } from 'vscode'; <del> import { CellOutputMetadata } from './common'; </del> <ins> import { CellOutputMetadata, type CellMetadata } from './common'; </ins> import { textMimeTypes } from './deserializers'; const textDecoder = new TextDecoder();


"command": "imagePreview.zoomOut", "title": "%command.zoomOut%", "category": "Image Preview" <ins> }, { "command": "imagePreview.copyImage", "title": "%command.copyImage%", "category": "Image Preview" </ins> } ], "menus": {


*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> .monaco-editor .lightbulb-glyph, .monaco-editor .codicon-lightbulb { </del> <ins> .monaco-editor .contentWidgets .codicon-light-bulb, .monaco-editor .contentWidgets .codicon-lightbulb-autofix { </ins> display: flex; align-items: center; justify-content: center; <del> height: 16px; width: 20px; padding-left: 2px; </del> } <del> .monaco-editor .lightbulb-glyph:hover, .monaco-editor .codicon-lightbulb:hover { </del> <ins> .monaco-editor .contentWidgets .codicon-light-bulb:hover, .monaco-editor .contentWidgets .codicon-lightbulb-autofix:hover { </ins> cursor: pointer; <del> /* transform: scale(1.3, 1.3); */ </del> }


'tmux': { path: 'tmux' } <del> } </del> <ins> }, additionalProperties: terminalProfileSchema </ins> }, 'terminal.integrated.showQuickLaunchWslProfiles': { description: localize('terminal.integrated.showQuickLaunchWslProfiles', 'Controls whether or not WSL distros are shown in the quick launch dropdown'),


this.searchWidget.setReplaceAllActionState(false); this.tree.setSelection([]); <ins> this.tree.setFocus([]); </ins> return this.viewModel.search(query) .then(onComplete, onError); }


padding: 0; } <del> .search-view:not(.wide) .foldermatch .monaco-icon-label, .search-view:not(.wide) .filematch .monaco-icon-label { flex: 1; } .search-view:not(.wide) .monaco-tree .monaco-tree-row:hover:not(.highlighted) .foldermatch .monaco-icon-label, .search-view:not(.wide) .monaco-tree .monaco-tree-row.focused .foldermatch .monaco-icon-label, .search-view:not(.wide) .monaco-tree .monaco-tree-row:hover:not(.highlighted) .filematch .monaco-icon-label, .search-view:not(.wide) .monaco-tree .monaco-tree-row.focused .filematch .monaco-icon-label { flex: 1; } </del> .search-view .foldermatch .directory, .search-view .filematch .directory { opacity: 0.7;


background-color: var(--vscode-editorWidget-background) !important; color: var(--vscode-editorWidget-foreground); box-shadow: 0 0 8px 2px var(--vscode-widget-shadow); <del> border: 1px solid var(--vscode-contrastBorder); </del> <ins> border: 1px solid var(--vscode-widget-border); </ins> border-bottom-left-radius: 4px; border-bottom-right-radius: 4px; font-size: 12px;


this.configurationRegistry.updateConfigurations({ add: [this.configurationNode], remove: oldConfigurationNode ? [oldConfigurationNode] : [] }); } } <ins> export class DefaultBinaryEditorConfiguration extends Disposable implements IWorkbenchContribution { private configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration); private configurationNode: IConfigurationNode | undefined; constructor( @IEditorResolverService private readonly editorResolverService: IEditorResolverService, @IExtensionService extensionService: IExtensionService, ) { super(); // Editor configurations are getting updated very aggressively // (atleast 20 times) while the extensions are getting registered. // As such push out the default binary editor configuration // until after extensions registered. (async () => { await extensionService.whenInstalledExtensionsRegistered(); this.updateConfiguration(); this.registerListeners(); })(); } private registerListeners(): void { // Registered editors this._register(this.editorResolverService.onDidChangeEditorRegistrations(() => this.updateConfiguration())); } private updateConfiguration(): void { // Get registered editors const editorIds = this.editorResolverService.getEditors().filter(e => e.priority !== RegisteredEditorPriority.exclusive).map(editor => editor.id); const oldConfigurationNode = this.configurationNode; this.configurationNode = { ...workbenchConfigurationNodeBase, properties: { 'workbench.editor.defaultBinaryEditor': { type: 'string', // This allows for intellisense autocompletion enum: editorIds, description: localize('workbench.editor.defaultBinaryEditor', "The default editor for files detected as binary. If undefined the user will be presented with a picker."), } } }; this.configurationRegistry.updateConfigurations({ add: [this.configurationNode], remove: oldConfigurationNode ? [oldConfigurationNode] : [] }); } } </ins>


resolved "https://registry.yarnpkg.com/request-light/-/request-light-0.7.0.tgz#885628bb2f8040c26401ebf258ec51c4ae98ac2a" integrity sha512-lMbBMrDoxgsyO+yB3sDcrDuX85yYt7sS8BfQd11jtbW/z5ZWgLZRcEGLsLoYw7I0WSUGQBs8CC8ScIxkTX1+6Q== <del> vscode-json-languageservice@^5.3.1: version "5.3.1" resolved "https://registry.yarnpkg.com/vscode-json-languageservice/-/vscode-json-languageservice-5.3.1.tgz#c36175d05f425fbd8f47dcee6f2a72096bdda36f" integrity sha512-tPRf/2LOBS6uFflFLABdj8T3ol2/QgZ0kpzZHFCs+cbxpnjBNiCo+rfh3th0dtdytq5dSnWo5iFJj99zF6jZWQ== </del> <ins> vscode-json-languageservice@^5.3.2: version "5.3.2" resolved "https://registry.yarnpkg.com/vscode-json-languageservice/-/vscode-json-languageservice-5.3.2.tgz#11e530ba9ec541eaeb421dc274a22efdb5d580ef" integrity sha512-5td6olfoNdtyxnNA4uocq7V9jdTJt63o9mGEntQb6cbD2HiObZW2XgbSj6nRaebWwBCiYdWpFklNjm6Wz6Xy1Q== </ins> dependencies: "@vscode/l10n" "^0.0.11" jsonc-parser "^3.2.0"


__vsc_original_prompt_command=${PROMPT_COMMAND[@]} fi <del> if [[ -n "$__vsc_original_prompt_command" && "$__vsc_original_prompt_command" != "__vsc_prompt_cmd" ]]; then PROMPT_COMMAND=__vsc_prompt_cmd_original else PROMPT_COMMAND=__vsc_prompt_cmd </del> <ins> if [[ -z "${bash_preexec_imported:-}" ]]; then if [[ -n "$__vsc_original_prompt_command" && "$__vsc_original_prompt_command" != "__vsc_prompt_cmd" ]]; then PROMPT_COMMAND=__vsc_prompt_cmd_original else PROMPT_COMMAND=__vsc_prompt_cmd fi </ins> fi


class Trait<T> implements ISpliceable<boolean>, IDisposable { <del> private length = 0; private indexes: number[] = []; private sortedIndexes: number[] = []; </del> <ins> protected indexes: number[] = []; protected sortedIndexes: number[] = []; </ins> private readonly _onChange = new Emitter<ITraitChangeEvent>(); readonly onChange: Event<ITraitChangeEvent> = this._onChange.event;


@IUserDataSyncWorkbenchService private readonly userDataSyncWorkbenchService: IUserDataSyncWorkbenchService, @IUserDataSyncEnablementService private readonly userDataSyncEnablementService: IUserDataSyncEnablementService, @IWorkspaceTrustManagementService private readonly workspaceTrustManagementService: IWorkspaceTrustManagementService, <del> @IExtensionService private readonly extensionService: IExtensionService </del> <ins> @IExtensionService private readonly extensionService: IExtensionService, @ILanguageService private readonly languageService: ILanguageService </ins> ) { super(SettingsEditor2.ID, telemetryService, themeService, storageService); this.delayedFilterLogging = new Delayer<void>(1000);


name: result.variable.name, value: result.variable.value, type: result.variable.type, <ins> language: result.variable.language, expression: result.variable.expression, </ins> hasNamedChildren: result.hasNamedChildren, indexedChildrenCount: result.indexedChildrenCount, extensionId: obj.extensionId.value,


<link rel="stylesheet" href="${escapeAttribute(this.extensionResource('media', 'imagePreview.css'))}" type="text/css" media="screen" nonce="${nonce}">  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src data: ${cspSource}; script-src 'nonce-${nonce}'; style-src ${cspSource} 'nonce-${nonce}';">   <meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src data: ${cspSource}; connect-src ${cspSource}; script-src 'nonce-${nonce}'; style-src ${cspSource} 'nonce-${nonce}';">  <meta id="image-preview-settings" data-settings="${escapeAttribute(JSON.stringify(settings))}">

${vscode.l10n.t("An error occurred while loading the image.")}


} public static moveToEndOfLine(config: CursorConfiguration, model: ICursorSimpleModel, cursor: SingleCursorState, inSelectionMode: boolean): SingleMoveOperationResult { <del> let lineNumber = cursor.selection.endLineNumber; </del> <ins> let lineNumber = cursor.position.lineNumber; </ins> let maxColumn = model.getLineMaxColumn(lineNumber); return SingleMoveOperationResult.fromMove(cursor, inSelectionMode, lineNumber, maxColumn, 0, true, CursorChangeReason.Explicit); }


this._onDidDeleteFile.fire(Object.freeze({ files: files.map(f => URI.revive(f.target)) })); break; case FileOperation.CREATE: <ins> case FileOperation.COPY: </ins> this._onDidCreateFile.fire(Object.freeze({ files: files.map(f => URI.revive(f.target)) })); break; default:


} async showStash(index: number): Promise<Change[] | undefined> { <del> const args = ['stash', 'show', `stash@{${index}}`, '--name-status', '-z']; </del> <ins> const args = ['stash', 'show', `stash@{${index}}`, '--name-status', '-z', '-u']; </ins> try { const result = await this.exec(args);


private compressedFocusLastContext: IContextKey<boolean>; private viewHasSomeCollapsibleRootItem: IContextKey<boolean>; <ins> private viewVisibleContextKey: IContextKey<boolean>; </ins> private horizontalScrolling: boolean | undefined;