resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8= <del> 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== </del> <ins> xterm-addon-search@0.9.0: version "0.9.0" resolved "https://registry.yarnpkg.com/xterm-addon-search/-/xterm-addon-search-0.9.0.tgz#95278ebb818cfcf882209ae75be96e0bea5d52a5" integrity sha512-aoolI8YuHvdGw+Qjg8g2M4kst0v86GtB7WeBm4F0jNXA005/6QbWWy9eCsvnIDLJOFI5JSSrZnD6CaOkvBQYPA== </ins> <del> xterm-addon-serialize@0.7.0-beta.15: version "0.7.0-beta.15" resolved "https://registry.yarnpkg.com/xterm-addon-serialize/-/xterm-addon-serialize-0.7.0-beta.15.tgz#0f7d5f9b423802ac67c2a891d74de530a4fe6a65" integrity sha512-gO/dxqGgOAuj7DN2ETTeCHyalkb655XogZh5408CmH5D6mjI1lxqVLGUdiFeBVU/OHfWZT2PZ95k06VXqLU5kA== </del> <ins> xterm-addon-serialize@0.7.0: version "0.7.0" resolved "https://registry.yarnpkg.com/xterm-addon-serialize/-/xterm-addon-serialize-0.7.0.tgz#cc7ef78972c8425b81dd6ae0a76824ce033d1e5f" integrity sha512-ZfZ4Zj4uTEBFnUA0exipDGZ14jfiWLCov7gIt2OwIjQEz2ey8ic5kL/cxYz5antNz8/hTSA2qZcyA6VyyQASOQ== </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.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== xterm-headless@4.19.0-beta.67: version "4.19.0-beta.67" resolved "https://registry.yarnpkg.com/xterm-headless/-/xterm-headless-4.19.0-beta.67.tgz#fe44a243974bf307c9a0694114ab45289734c7f9" integrity sha512-rpxUsE/te2LN4B/erI108uaAhuLTUsnRl9zIZgcqMqZGFRqDUTtyVM05jIA/8A32g06wFd3WioTkeKc6ow+sLg== 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== </del> <ins> xterm-addon-webgl@0.12.0: version "0.12.0" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.12.0.tgz#2fba8d31890a122adafa1c2fb945482e2ae12973" integrity sha512-3P5ihdjPnxH6Wrvqjki9UD+duoVrp1fvnO/pSpXP2F1L2GwY6TDNExgj8Yg141vMCNgQbcVqmsTLYEYZxjY92A== xterm-headless@4.19.0: version "4.19.0" resolved "https://registry.yarnpkg.com/xterm-headless/-/xterm-headless-4.19.0.tgz#965eb293fe6258adff5888f24e2a0b778b765e17" integrity sha512-rYP8I1AGwaztpCoWe9mwxNqmfz7zZCjbzw61QChFqPeiDERjW9CDnqyGhSElvicHAlf47dvA+p4qOuKltxWEkg== xterm@4.19.0: version "4.19.0" resolved "https://registry.yarnpkg.com/xterm/-/xterm-4.19.0.tgz#c0f9d09cd61de1d658f43ca75f992197add9ef6d" integrity sha512-c3Cp4eOVsYY5Q839dR5IejghRPpxciGmLWWaP9g+ppfMeBChMeLa1DCA+pmX/jyDZ+zxFOmlJL/82qVdayVoGQ== </ins> yallist@^4.0.0: version "4.0.0"


dependencies: object-keys "~0.4.0" <del> 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== </del> <ins> xterm-addon-search@0.9.0: version "0.9.0" resolved "https://registry.yarnpkg.com/xterm-addon-search/-/xterm-addon-search-0.9.0.tgz#95278ebb818cfcf882209ae75be96e0bea5d52a5" integrity sha512-aoolI8YuHvdGw+Qjg8g2M4kst0v86GtB7WeBm4F0jNXA005/6QbWWy9eCsvnIDLJOFI5JSSrZnD6CaOkvBQYPA== </ins> <del> xterm-addon-serialize@0.7.0-beta.15: version "0.7.0-beta.15" resolved "https://registry.yarnpkg.com/xterm-addon-serialize/-/xterm-addon-serialize-0.7.0-beta.15.tgz#0f7d5f9b423802ac67c2a891d74de530a4fe6a65" integrity sha512-gO/dxqGgOAuj7DN2ETTeCHyalkb655XogZh5408CmH5D6mjI1lxqVLGUdiFeBVU/OHfWZT2PZ95k06VXqLU5kA== </del> <ins> xterm-addon-serialize@0.7.0: version "0.7.0" resolved "https://registry.yarnpkg.com/xterm-addon-serialize/-/xterm-addon-serialize-0.7.0.tgz#cc7ef78972c8425b81dd6ae0a76824ce033d1e5f" integrity sha512-ZfZ4Zj4uTEBFnUA0exipDGZ14jfiWLCov7gIt2OwIjQEz2ey8ic5kL/cxYz5antNz8/hTSA2qZcyA6VyyQASOQ== </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.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== xterm-headless@4.19.0-beta.67: version "4.19.0-beta.67" resolved "https://registry.yarnpkg.com/xterm-headless/-/xterm-headless-4.19.0-beta.67.tgz#fe44a243974bf307c9a0694114ab45289734c7f9" integrity sha512-rpxUsE/te2LN4B/erI108uaAhuLTUsnRl9zIZgcqMqZGFRqDUTtyVM05jIA/8A32g06wFd3WioTkeKc6ow+sLg== 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== </del> <ins> xterm-addon-webgl@0.12.0: version "0.12.0" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.12.0.tgz#2fba8d31890a122adafa1c2fb945482e2ae12973" integrity sha512-3P5ihdjPnxH6Wrvqjki9UD+duoVrp1fvnO/pSpXP2F1L2GwY6TDNExgj8Yg141vMCNgQbcVqmsTLYEYZxjY92A== xterm-headless@4.19.0: version "4.19.0" resolved "https://registry.yarnpkg.com/xterm-headless/-/xterm-headless-4.19.0.tgz#965eb293fe6258adff5888f24e2a0b778b765e17" integrity sha512-rYP8I1AGwaztpCoWe9mwxNqmfz7zZCjbzw61QChFqPeiDERjW9CDnqyGhSElvicHAlf47dvA+p4qOuKltxWEkg== xterm@4.19.0: version "4.19.0" resolved "https://registry.yarnpkg.com/xterm/-/xterm-4.19.0.tgz#c0f9d09cd61de1d658f43ca75f992197add9ef6d" integrity sha512-c3Cp4eOVsYY5Q839dR5IejghRPpxciGmLWWaP9g+ppfMeBChMeLa1DCA+pmX/jyDZ+zxFOmlJL/82qVdayVoGQ== </ins> y18n@^3.2.1: version "3.2.2"


} renderElement(element: MarkerTableItem, index: number, templateData: IMarkerCodeColumnTemplateData, height: number | undefined): void { <del> if (element.marker.source && element.marker.code) { templateData.codeColumn.classList.toggle('code-link', typeof element.marker.code !== 'string'); DOM.show(templateData.codeLabel.element); </del> <ins> templateData.codeColumn.classList.remove('code-label'); templateData.codeColumn.classList.remove('code-link'); if (element.marker.source && element.marker.code) { </ins> if (typeof element.marker.code === 'string') { <ins> templateData.codeColumn.classList.add('code-label'); </ins> templateData.codeColumn.title = `${element.marker.source} (${element.marker.code})`; templateData.sourceLabel.set(element.marker.source, element.sourceMatches); templateData.codeLabel.set(element.marker.code, element.codeMatches); } else { <ins> templateData.codeColumn.classList.add('code-link'); </ins> templateData.codeColumn.title = `${element.marker.source} (${element.marker.code.value})`; templateData.sourceLabel.set(element.marker.source, element.sourceMatches);


} else { templateData.codeColumn.title = ''; templateData.sourceLabel.set('-'); <del> DOM.hide(templateData.codeLabel.element); </del> } }


content: ')'; } <del> .markers-panel .markers-table-container .monaco-table .monaco-list-row .monaco-table-tr > .monaco-table-td > .code.code-link > .code-label { </del> <ins> .markers-panel .markers-table-container .monaco-table .monaco-list-row .monaco-table-tr > .monaco-table-td > .code > .code-label, .markers-panel .markers-table-container .monaco-table .monaco-list-row .monaco-table-tr > .monaco-table-td > .code > .monaco-link { </ins> display: none; } <del> .markers-panel .markers-table-container .monaco-table .monaco-list-row .monaco-table-tr > .monaco-table-td > .code.code-link > .monaco-link { </del> <ins> .markers-panel .markers-table-container .monaco-table .monaco-list-row .monaco-table-tr > .monaco-table-td > .code.code-label > .code-label { </ins> display: inline; <del> text-decoration: underline; </del> } <del> .markers-panel .markers-table-container .monaco-table .monaco-list-row .monaco-table-tr > .monaco-table-td > .code > .monaco-link { display: none; </del> <ins> .markers-panel .markers-table-container .monaco-table .monaco-list-row .monaco-table-tr > .monaco-table-td > .code.code-link > .monaco-link { display: inline; text-decoration: underline; </ins> } .markers-panel .markers-table-container .monaco-table .monaco-list-row .monaco-table-tr > .monaco-table-td > .file > .file-position {


interface ActionButtonState { readonly HEAD: Branch | undefined; readonly isCommitInProgress: boolean; <ins> readonly isMergeInProgress: boolean; </ins> readonly isSyncInProgress: boolean; readonly repositoryHasChanges: boolean; }


private disposables: Disposable[] = []; constructor(readonly repository: Repository) { <del> this._state = { HEAD: undefined, isCommitInProgress: false, isSyncInProgress: false, repositoryHasChanges: false }; </del> <ins> this._state = { HEAD: undefined, isCommitInProgress: false, isMergeInProgress: false, isSyncInProgress: false, repositoryHasChanges: false }; </ins> repository.onDidRunGitStatus(this.onDidRunGitStatus, this, this.disposables); repository.onDidChangeOperations(this.onDidChangeOperations, this, this.disposables);


}, ] ], <del> enabled: this.state.repositoryHasChanges && !this.state.isCommitInProgress </del> <ins> enabled: this.state.repositoryHasChanges && !this.state.isCommitInProgress && !this.state.isMergeInProgress </ins> }; }


const config = workspace.getConfiguration('git', Uri.file(this.repository.root)); const showActionButton = config.get<{ publish: boolean }>('showActionButton', { publish: true }); <del> // Branch does have an upstream, commit is in progress, or the button is disabled if (this.state.HEAD?.upstream || this.state.isCommitInProgress || !showActionButton.publish) { return undefined; } </del> <ins> // Branch does have an upstream, commit/merge is in progress, or the button is disabled if (this.state.HEAD?.upstream || this.state.isCommitInProgress || this.state.isMergeInProgress || !showActionButton.publish) { return undefined; } </ins> return { command: {


const config = workspace.getConfiguration('git', Uri.file(this.repository.root)); const showActionButton = config.get<{ sync: boolean }>('showActionButton', { sync: true }); <del> // Branch does not have an upstream, commit is in progress, or the button is disabled if (!this.state.HEAD?.upstream || this.state.isCommitInProgress || !showActionButton.sync) { return undefined; } </del> <ins> // Branch does not have an upstream, commit/merge is in progress, or the button is disabled if (!this.state.HEAD?.upstream || this.state.isCommitInProgress || this.state.isMergeInProgress || !showActionButton.sync) { return undefined; } </ins> const ahead = this.state.HEAD.ahead ? ` ${this.state.HEAD.ahead}$(arrow-up)` : ''; const behind = this.state.HEAD.behind ? ` ${this.state.HEAD.behind}$(arrow-down)` : '';


this.state = { ...this.state, HEAD: this.repository.HEAD, <ins> isMergeInProgress: this.repository.mergeGroup.resourceStates.length !== 0, </ins> repositoryHasChanges: this.repository.indexGroup.resourceStates.length !== 0 || <del> this.repository.mergeGroup.resourceStates.length !== 0 || </del> this.repository.untrackedGroup.resourceStates.length !== 0 || this.repository.workingTreeGroup.resourceStates.length !== 0 };


setTimeout(() => document.body.removeChild(dragImage), 0); } <ins> this.domNode.classList.add('dragging'); </ins> this.currentDragData = new ElementsDragAndDropData(elements); StaticDND.CurrentDragAndDropData = new ExternalElementsDragAndDropData(elements);


const dragData = this.currentDragData; this.teardownDragAndDropScrollTopAnimation(); this.clearDragOverFeedback(); <ins> this.domNode.classList.remove('dragging'); </ins> this.currentDragData = undefined; StaticDND.CurrentDragAndDropData = undefined;


this.canDrop = false; this.teardownDragAndDropScrollTopAnimation(); this.clearDragOverFeedback(); <ins> this.domNode.classList.remove('dragging'); </ins> this.currentDragData = undefined; StaticDND.CurrentDragAndDropData = undefined;


} if (styles.listHoverBackground) { <del> content.push(`.monaco-list${suffix}:not(.drop-target) .monaco-list-row:hover:not(.selected):not(.focused) { background-color: ${styles.listHoverBackground}; }`); </del> <ins> content.push(`.monaco-list${suffix}:not(.drop-target):not(.dragging) .monaco-list-row:hover:not(.selected):not(.focused) { background-color: ${styles.listHoverBackground}; }`); </ins> } if (styles.listHoverForeground) { <del> content.push(`.monaco-list${suffix} .monaco-list-row:hover:not(.selected):not(.focused) { color:  ${styles.listHoverForeground}; }`); </del> <ins> content.push(`.monaco-list${suffix}:not(.drop-target):not(.dragging) .monaco-list-row:hover:not(.selected):not(.focused) { color:  ${styles.listHoverForeground}; }`); </ins> } if (styles.listSelectionOutline) {


listDropBackground?: Color; } <del> // Accepts a single or multiple workspace folders function hasExpandedRootChild(tree: WorkbenchCompressibleAsyncDataTree<ExplorerItem | ExplorerItem[], ExplorerItem, FuzzyScore>, treeInput: ExplorerItem | ExplorerItem[]): boolean { const inputsToCheck = []; if (Array.isArray(treeInput)) { inputsToCheck.push(...treeInput.filter(folder => tree.hasNode(folder) && !tree.isCollapsed(folder))); } else { inputsToCheck.push(treeInput); } for (const folder of inputsToCheck) { for (const [, child] of folder.children.entries()) { if (tree.hasNode(child) && tree.isCollapsible(child) && !tree.isCollapsed(child)) { return true; </del> <ins> function hasExpandedRootChild(tree: WorkbenchCompressibleAsyncDataTree<ExplorerItem | ExplorerItem[], ExplorerItem, FuzzyScore>, treeInput: ExplorerItem[]): boolean { for (const folder of treeInput) { if (tree.hasNode(folder) && !tree.isCollapsed(folder)) { for (const [, child] of folder.children.entries()) { if (tree.hasNode(child) && tree.isCollapsible(child) && !tree.isCollapsed(child)) { return true; } </ins> } } } <ins> return false; } /** * Whether or not any of the nodes in the tree are expanded */ function hasExpandedNode(tree: WorkbenchCompressibleAsyncDataTree<ExplorerItem | ExplorerItem[], ExplorerItem, FuzzyScore>, treeInput: ExplorerItem[]): boolean { for (const folder of treeInput) { if (tree.hasNode(folder) && !tree.isCollapsed(folder)) { return true; } } </ins> return false; }


this.tree.domFocus(); } <del> const treeInput = this.tree.getInput(); if (Array.isArray(treeInput)) { treeInput.forEach(folder => { folder.children.forEach(child => this.tree.hasNode(child) && this.tree.expand(child, true)); }); return; } </del> this.tree.expandAll(); }


if (treeInput === undefined) { return; } <del> this.viewHasSomeCollapsibleRootItem.set(hasExpandedRootChild(this.tree, treeInput)); </del> <ins> const treeInputArray = Array.isArray(treeInput) ? treeInput : Array.from(treeInput.children.values()); // Has collapsible root when anything is expanded this.viewHasSomeCollapsibleRootItem.set(hasExpandedNode(this.tree, treeInputArray)); </ins> } styleListDropBackground(styles: IExplorerViewStyles): void {


private _terminals: IStringDictionary<ITerminalData>; private _idleTaskTerminals: LinkedMap<string, string>; private _sameTaskTerminals: IStringDictionary<string>; <ins> private _terminalForTask: ITerminalInstance | undefined; </ins> private _taskSystemInfoResolver: ITaskSystemInfoResolver; private _lastTask: VerifiedTask | undefined; // Should always be set in run


this._reconnectToTerminals(terminals); } if (this._tasksToReconnect.includes(task._id)) { <del> this._lastTask = new VerifiedTask(task, resolver, trigger); this.rerun(); </del> <ins> this._terminalForTask = terminals.find(t => t.shellLaunchConfig.attachPersistentProcess?.task?.id === task._id); this.run(task, resolver, trigger); </ins> } return undefined; }


} try { <del> const executeResult = { kind: TaskExecuteKind.Started, task, started: {}, promise: this._executeTask(task, resolver, trigger, new Set()) }; </del> <ins> const executeResult = { kind: TaskExecuteKind.Started, task, started: {}, promise: this._executeTask(task, resolver, trigger, new Set(), undefined) }; </ins> executeResult.promise.then(summary => { this._lastTask = this._currentTask; });


})); watchingProblemMatcher.aboutToStart(); let delayer: Async.Delayer<any> | undefined = undefined; <del> [terminal, error] = await this._createTerminal(task, resolver, workspaceFolder); </del> <ins> [terminal, error] = this._terminalForTask ? [this._terminalForTask, undefined] : await this._createTerminal(task, resolver, workspaceFolder); </ins> if (error) { return Promise.reject(new Error((<TaskError>error).message));


}); }); } else { <del> [terminal, error] = await this._createTerminal(task, resolver, workspaceFolder); </del> <ins> [terminal, error] = this._terminalForTask ? [this._terminalForTask, undefined] : await this._createTerminal(task, resolver, workspaceFolder); </ins> if (error) { return Promise.reject(new Error((<TaskError>error).message));


import { EditSessionsDataViews } from 'vs/workbench/contrib/editSessions/browser/editSessionsViews'; import { ITextModelService } from 'vs/editor/common/services/resolverService'; import { EditSessionsContentProvider } from 'vs/workbench/contrib/editSessions/browser/editSessionsContentProvider'; <ins> import { isNative } from 'vs/base/common/platform'; import { WorkspaceFolderCountContext } from 'vs/workbench/common/contextkeys'; </ins> registerSingleton(IEditSessionsLogService, EditSessionsLogService); registerSingleton(IEditSessionsWorkbenchService, EditSessionsWorkbenchService);


id: '_workbench.experimental.editSessions.actions.continueEditSession', title: { value: localize('continue edit session', "Continue Edit Session..."), original: 'Continue Edit Session...' }, category: EDIT_SESSION_SYNC_CATEGORY, <ins> precondition: WorkspaceFolderCountContext.notEqualsTo('0'), </ins> f1: true }; const openLocalFolderCommand: IAction2Options = {


private createPickItems(): ContinueEditSessionItem[] { const items = [...this.continueEditSessionOptions].filter((option) => option.when === undefined || this.contextKeyService.contextMatchesRules(option.when)); <del> if (getVirtualWorkspaceLocation(this.contextService.getWorkspace()) !== undefined) { </del> <ins> if (getVirtualWorkspaceLocation(this.contextService.getWorkspace()) !== undefined && isNative) { </ins> items.push(new ContinueEditSessionItem( localize('continueEditSessionItem.openInLocalFolder', 'Open In Local Folder'), openLocalFolderCommand.id,


constructor() { super({ id: 'workbench.editSessions.actions.resetAuth', <del> title: localize('reset auth', 'Sign Out'), </del> <ins> title: localize('reset auth.v2', 'Sign Out of Edit Sessions'), </ins> category: EDIT_SESSION_SYNC_CATEGORY, precondition: ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, true), menu: [{


} override get capabilities(): EditorInputCapabilities { <del> return EditorInputCapabilities.Readonly | EditorInputCapabilities.Singleton; </del> <ins> return EditorInputCapabilities.Readonly | EditorInputCapabilities.Singleton | EditorInputCapabilities.CanDropIntoEditor; </ins> } setTerminalInstance(instance: ITerminalInstance): void {


ShellIntegrationEnabled = 'terminal.integrated.shellIntegration.enabled', ShellIntegrationShowWelcome = 'terminal.integrated.shellIntegration.showWelcome', ShellIntegrationDecorationsEnabled = 'terminal.integrated.shellIntegration.decorationsEnabled', <del> ShellIntegrationDecorationIcon = 'terminal.integrated.shellIntegration.decorationIcon', ShellIntegrationDecorationIconError = 'terminal.integrated.shellIntegration.decorationIconError', ShellIntegrationDecorationIconSuccess = 'terminal.integrated.shellIntegration.decorationIconSuccess', </del> ShellIntegrationCommandHistory = 'terminal.integrated.shellIntegration.history', SmoothScrolling = 'terminal.integrated.smoothScrolling' }


Default = 'default', Codicon = 'codicon', XtermDecoration = 'xterm-decoration', <del> GenericMarkerIcon = 'codicon-circle-small-filled', </del> OverviewRuler = '.xterm-decoration-overview-ruler' }


this._hoverDelayer = this._register(new Delayer(this._configurationService.getValue('workbench.hover.delay'))); this._register(this._configurationService.onDidChangeConfiguration(e => { <del> if (e.affectsConfiguration(TerminalSettingId.ShellIntegrationDecorationIcon) || e.affectsConfiguration(TerminalSettingId.ShellIntegrationDecorationIconSuccess) || e.affectsConfiguration(TerminalSettingId.ShellIntegrationDecorationIconError)) { this._refreshStyles(); } else if (e.affectsConfiguration(TerminalSettingId.FontSize) || e.affectsConfiguration(TerminalSettingId.LineHeight)) { </del> <ins> if (e.affectsConfiguration(TerminalSettingId.FontSize) || e.affectsConfiguration(TerminalSettingId.LineHeight)) { </ins> this.refreshLayouts(); } else if (e.affectsConfiguration('workbench.colorCustomizations')) { this._refreshStyles(true);


element.classList.add(DecorationSelector.CommandDecoration, DecorationSelector.Codicon, DecorationSelector.XtermDecoration); if (genericMarkProperties) { <del> element.classList.add(DecorationSelector.DefaultColor, DecorationSelector.GenericMarkerIcon); </del> <ins> element.classList.add(DecorationSelector.DefaultColor, ...Codicon.terminalDecorationMark.classNamesArray); </ins> if (!genericMarkProperties.hoverMessage) { //disable the mouse pointer element.classList.add(DecorationSelector.Default);


this._updateCommandDecorationVisibility(element); if (exitCode === undefined) { element.classList.add(DecorationSelector.DefaultColor, DecorationSelector.Default); <del> element.classList.add(`codicon-${this._configurationService.getValue(TerminalSettingId.ShellIntegrationDecorationIcon)}`); </del> <ins> element.classList.add(...Codicon.terminalDecorationIncomplete.classNamesArray); </ins> } else if (exitCode) { element.classList.add(DecorationSelector.ErrorColor); <del> element.classList.add(`codicon-${this._configurationService.getValue(TerminalSettingId.ShellIntegrationDecorationIconError)}`); </del> <ins> element.classList.add(...Codicon.terminalDecorationError.classNamesArray); </ins> } else { <del> element.classList.add(`codicon-${this._configurationService.getValue(TerminalSettingId.ShellIntegrationDecorationIconSuccess)}`); </del> <ins> element.classList.add(...Codicon.terminalDecorationSuccess.classNamesArray); </ins> } } }


private async _showConfigureCommandDecorationsQuickPick() { const quickPick = this._quickInputService.createQuickPick(); quickPick.items = [ <del> { id: 'a', label: localize('changeDefaultIcon', 'Change default icon') }, { id: 'b', label: localize('changeSuccessIcon', 'Change success icon') }, { id: 'c', label: localize('changeErrorIcon', 'Change error icon') }, { type: 'separator' }, { id: 'd', label: localize('toggleVisibility', 'Toggle visibility') }, </del> <ins> { id: 'a', label: localize('toggleVisibility', 'Toggle visibility') }, </ins> ]; quickPick.canSelectMany = false; quickPick.onDidAccept(async e => {


const result = quickPick.activeItems[0]; let iconSetting: string | undefined; switch (result.id) { <del> case 'a': iconSetting = TerminalSettingId.ShellIntegrationDecorationIcon; break; case 'b': iconSetting = TerminalSettingId.ShellIntegrationDecorationIconSuccess; break; case 'c': iconSetting = TerminalSettingId.ShellIntegrationDecorationIconError; break; case 'd': this._showToggleVisibilityQuickPick(); break; </del> <ins> case 'a': this._showToggleVisibilityQuickPick(); break; </ins> } if (iconSetting) { this._showChangeIconQuickPick(iconSetting);


default: 'view', description: localize('terminal.integrated.defaultLocation', "Controls where newly created terminals will appear.") }, <del> [TerminalSettingId.ShellIntegrationDecorationIconSuccess]: { type: 'string', default: 'primitive-dot', markdownDescription: localize('terminal.integrated.shellIntegration.decorationIconSuccess', "Controls the icon that will be used for each command in terminals with shell integration enabled that do not have an associated exit code. Set to {0} to hide the icon or disable decorations with {1}.", '`""`', '`#terminal.integrated.shellIntegration.decorationsEnabled#`') }, [TerminalSettingId.ShellIntegrationDecorationIconError]: { type: 'string', default: 'error-small', markdownDescription: localize('terminal.integrated.shellIntegration.decorationIconError', "Controls the icon that will be used for each command in terminals with shell integration enabled that do have an associated exit code. Set to {0} to hide the icon or disable decorations with {1}.", '`""`', '`#terminal.integrated.shellIntegration.decorationsEnabled#`') }, [TerminalSettingId.ShellIntegrationDecorationIcon]: { type: 'string', default: 'circle-outline', markdownDescription: localize('terminal.integrated.shellIntegration.decorationIcon', "Controls the icon that will be used for skipped/empty commands. Set to {0} to hide the icon or disable decorations with {1}.", '`""`', '`#terminal.integrated.shellIntegration.decorationsEnabled#`') }, </del> [TerminalSettingId.TabsFocusMode]: { type: 'string', enum: ['singleClick', 'doubleClick'],


export enum Selector { TerminalView = `#terminal`, <del> CommandDecorationPlaceholder = `.terminal-command-decoration.codicon-circle-outline`, CommandDecorationSuccess = `.terminal-command-decoration.codicon-primitive-dot`, CommandDecorationError = `.terminal-command-decoration.codicon-error-small`, </del> <ins> CommandDecorationPlaceholder = `.terminal-command-decoration.codicon-terminal-decoration-incomplete`, CommandDecorationSuccess = `.terminal-command-decoration.codicon-terminal-decoration-success`, CommandDecorationError = `.terminal-command-decoration.codicon-terminal-decoration-error`, </ins> Xterm = `#terminal .terminal-wrapper`, XtermEditor = `.editor-instance .terminal-wrapper`, TabsEntry = '.terminal-tabs-entry',


await terminal.assertCommandDecorations({ placeholder: 1, success: 0, error: 1 }); }); }); <del> describe('Custom configuration', function () { it('Should update and show custom icons', async () => { await createShellIntegrationProfile(); await terminal.assertCommandDecorations({ placeholder: 1, success: 0, error: 0 }); await terminal.runCommandInTerminal(`echo "foo"`); await terminal.runCommandInTerminal(`bar`); await settingsEditor.addUserSetting('terminal.integrated.shellIntegration.decorationIcon', '"zap"'); await settingsEditor.addUserSetting('terminal.integrated.shellIntegration.decorationIconSuccess', '"zap"'); await settingsEditor.addUserSetting('terminal.integrated.shellIntegration.decorationIconError', '"zap"'); await terminal.assertCommandDecorations(undefined, { updatedIcon: "zap", count: 3 }); }); }); </del> describe('terminal.integrated.shellIntegration.decorationsEnabled should determine gutter and overview ruler decoration visibility', function () { beforeEach(async () => { await settingsEditor.clearUserSettings();


__vsc_update_prompt <ins> __vsc_restore_exit_code() { return $1 } </ins> __vsc_prompt_cmd_original() { __vsc_status="$?" # Evaluate the original PROMPT_COMMAND similarly to how bash would normally


eval "${cmd:-}" done else <ins> __vsc_restore_exit_code "${__vsc_status}" </ins> eval "${__vsc_original_prompt_command:-}" fi __vsc_precmd


disturl "https://electronjs.org/headers" <del> target "19.0.11" </del> <ins> target "19.0.12" </ins> runtime "electron" build_from_source "true"


"git": { "name": "electron", "repositoryUrl": "https://github.com/electron/electron", <del> "commitHash": "a5cafd174d2027529d0b251e5b8e58da2b364e5b" </del> <ins> "commitHash": "b05ccd812e3bb3de5b1546a313e298961653e942" </ins> } }, "isOnlyProductionDependency": true, "license": "MIT", <del> "version": "19.0.11" </del> <ins> "version": "19.0.12" </ins> }, { "component": {


"cssnano": "^4.1.11", "debounce": "^1.0.0", "deemon": "^1.4.0", <del> "electron": "19.0.11", </del> <ins> "electron": "19.0.12", </ins> "eslint": "8.7.0", "eslint-plugin-header": "3.1.1", "eslint-plugin-jsdoc": "^39.3.2",


constructor(modulePath: string, args?: string[] | undefined, options?: UtilityProcessOptions); postMessage(channel: string, message: any, transfer?: Electron.MessagePortMain[]): void; kill(signal?: number | string): boolean; <del> on(event: 'exit', listener: (code: number | undefined) => void): this; </del> <ins> on(event: 'exit', listener: (event: Electron.Event, code: number) => void): this; </ins> on(event: 'spawn', listener: () => void): this; } }


this._register(Event.fromNodeEventEmitter<void>(this._process, 'spawn')(() => { this._logService.info(`UtilityProcess<${this.id}>: received spawn event.`); })); <del> this._register(Event.fromNodeEventEmitter<number | undefined>(this._process, 'exit')((code: number | undefined) => { code = code || 0; </del> <ins> const onExit = Event.fromNodeEventEmitter<number>(this._process, 'exit', (_, code: number) => code); this._register(onExit((code: number) => { </ins> this._logService.info(`UtilityProcess<${this.id}>: received exit event with code ${code}.`); this._hasExited = true; this._onExit.fire({ pid: this._process!.pid!, code, signal: '' });


resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.207.tgz#9c3310ebace2952903d05dcaba8abe3a4ed44c01" integrity sha512-piH7MJDJp4rJCduWbVvmUd59AUne1AFBJ8JaRQvk0KzNTSUnZrVXHCZc+eg+CGE4OujkcLJznhGKD6tuAshj5Q== <del> electron@19.0.11: version "19.0.11" resolved "https://registry.yarnpkg.com/electron/-/electron-19.0.11.tgz#0c0a52abc08694fd38916d9270baf45bb7752a27" integrity sha512-GPM6C1Ze17/gR4koTE171MxrI5unYfFRgXQdkMdpWM2Cd55LMUrVa0QHCsfKpsaloufv9T65lsOn0uZuzCw5UA== </del> <ins> electron@19.0.12: version "19.0.12" resolved "https://registry.yarnpkg.com/electron/-/electron-19.0.12.tgz#73d11cc2a3e4dbcd61fdc1c39561e7a7911046e9" integrity sha512-GOvG0t2NCeJYIfmC3g/dnEAQ71k3nQDbRVqQhpi2YbsYMury0asGJwqnVAv2uZQEwCwSx4XOwOQARTFEG/msWw== </ins> dependencies: "@electron/get" "^1.14.1" "@types/node" "^16.11.26"


import * as path from 'path'; import * as vscode from 'vscode'; import * as URI from 'vscode-uri'; <ins> import { Schemes } from '../util/schemes'; </ins> const imageFileExtensions = new Set<string>([ '.bmp',


return; } <ins> const docUri = getParentDocumentUri(document); </ins> const snippet = new vscode.SnippetString(); uris.forEach((uri, i) => { <del> const mdPath = document.uri.scheme === uri.scheme ? encodeURI(path.relative(URI.Utils.dirname(document.uri).fsPath, uri.fsPath).replace(//g, '/')) </del> <ins> const mdPath = docUri.scheme === uri.scheme && docUri.authority === uri.authority ? encodeURI(path.relative(URI.Utils.dirname(docUri).fsPath, uri.fsPath).replace(//g, '/')) </ins> : uri.toString(false); const ext = URI.Utils.extname(uri).toLowerCase();


return snippet; } <ins> function getParentDocumentUri(document: vscode.TextDocument): vscode.Uri { if (document.uri.scheme === Schemes.notebookCell) { for (const notebook of vscode.workspace.notebookDocuments) { for (const cell of notebook.getCells()) { if (cell.document === document) { return notebook.uri; } } } } return document.uri; } </ins>


const actions: string[] = [ localize('saveWithConflict', "Save with Conflicts"), <del> localize('discard', "Don't save"), </del> <ins> localize('discard', "Don't Save"), </ins> localize('cancel', "Cancel"), ];


const inputModel = await input.resolve(); const model = inputModel.model; <del> const viewModel = new MergeEditorViewModel(model, this.input1View, this.input2View, this.inputResultView, this.baseView, this.showNonConflictingChanges, this.configurationService); </del> <ins> const viewModel = this.instantiationService.createInstance( MergeEditorViewModel, model, this.input1View, this.input2View, this.inputResultView, this.baseView, this.showNonConflictingChanges, ); </ins> model.telemetry.reportMergeEditorOpened({


import { derived, derivedObservableWithWritableCache, IObservable, IReader, ITransaction, observableFromEvent, observableValue, transaction } from 'vs/base/common/observable'; import { Range } from 'vs/editor/common/core/range'; import { ScrollType } from 'vs/editor/common/editorCommon'; <ins> import { localize } from 'vs/nls'; </ins> import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; <ins> import { INotificationService } from 'vs/platform/notification/common/notification'; </ins> import { LineRange } from 'vs/workbench/contrib/mergeEditor/browser/model/lineRange'; import { MergeEditorModel } from 'vs/workbench/contrib/mergeEditor/browser/model/mergeEditorModel'; import { ModifiedBaseRange, ModifiedBaseRangeState } from 'vs/workbench/contrib/mergeEditor/browser/model/modifiedBaseRange';


public readonly resultCodeEditorView: ResultCodeEditorView, public readonly baseCodeEditorView: IObservable<BaseCodeEditorView | undefined>, public readonly showNonConflictingChanges: IObservable<boolean>, <del> @IConfigurationService public readonly configurationService: IConfigurationService, </del> <ins> @IConfigurationService private readonly configurationService: IConfigurationService, @INotificationService private readonly notificationService: INotificationService </ins> ) { super();


public toggleActiveConflict(inputNumber: 1 | 2): void { const activeModifiedBaseRange = this.activeModifiedBaseRange.get(); if (!activeModifiedBaseRange) { <ins> this.notificationService.error(localize('noConflictMessage', "There is currently no conflict focused that can be toggled.")); </ins> return; } transaction(tx => {


} .extension-list-item > .details > .footer > .monaco-action-bar > .actions-container .action-label:not(.icon) { <del> border-radius: 0; </del> <ins> border-radius: 2px; </ins> } .extension-list-item > .details > .footer > .monaco-action-bar > .actions-container .extension-action.label {


import { consumeStream, isReadableBufferedStream, isReadableStream, listenStream, newWriteableStream, peekReadable, peekStream, transform } from 'vs/base/common/stream'; import { URI } from 'vs/base/common/uri'; import { localize } from 'vs/nls'; <del> import { ensureFileSystemProviderError, etag, ETAG_DISABLED, FileChangesEvent, IFileDeleteOptions, FileOperation, FileOperationError, FileOperationEvent, FileOperationResult, FilePermission, FileSystemProviderCapabilities, FileSystemProviderErrorCode, FileType, hasFileAtomicReadCapability, hasFileFolderCopyCapability, hasFileReadStreamCapability, hasOpenReadWriteCloseCapability, hasReadWriteCapability, ICreateFileOptions, IFileContent, IFileService, IFileStat, IFileStatWithMetadata, IFileStreamContent, IFileSystemProvider, IFileSystemProviderActivationEvent, IFileSystemProviderCapabilitiesChangeEvent, IFileSystemProviderRegistrationEvent, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IReadFileOptions, IReadFileStreamOptions, IResolveFileOptions, IFileStatResult, IFileStatResultWithMetadata, IResolveMetadataFileOptions, IStat, IFileStatWithPartialMetadata, IWatchOptions, IWriteFileOptions, NotModifiedSinceFileOperationError, toFileOperationResult, toFileSystemProviderErrorCode, hasFileCloneCapability, hasFileReadCapability, IFileSystemProviderWithFileReadCapability } from 'vs/platform/files/common/files'; </del> <ins> import { ensureFileSystemProviderError, etag, ETAG_DISABLED, FileChangesEvent, IFileDeleteOptions, FileOperation, FileOperationError, FileOperationEvent, FileOperationResult, FilePermission, FileSystemProviderCapabilities, FileSystemProviderErrorCode, FileType, hasFileAtomicReadCapability, hasFileFolderCopyCapability, hasFileReadStreamCapability, hasOpenReadWriteCloseCapability, hasReadWriteCapability, ICreateFileOptions, IFileContent, IFileService, IFileStat, IFileStatWithMetadata, IFileStreamContent, IFileSystemProvider, IFileSystemProviderActivationEvent, IFileSystemProviderCapabilitiesChangeEvent, IFileSystemProviderRegistrationEvent, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IReadFileOptions, IReadFileStreamOptions, IResolveFileOptions, IFileStatResult, IFileStatResultWithMetadata, IResolveMetadataFileOptions, IStat, IFileStatWithPartialMetadata, IWatchOptions, IWriteFileOptions, NotModifiedSinceFileOperationError, toFileOperationResult, toFileSystemProviderErrorCode, hasFileCloneCapability } from 'vs/platform/files/common/files'; </ins> import { readFileIntoStream } from 'vs/platform/files/common/io'; import { ILogService } from 'vs/platform/log/common/log';


return provider; } <del> private async withReadProvider(resource: URI): Promise<IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithOpenReadWriteCloseCapability | IFileSystemProviderWithFileReadStreamCapability | IFileSystemProviderWithFileReadCapability> { </del> <ins> private async withReadProvider(resource: URI): Promise<IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithOpenReadWriteCloseCapability | IFileSystemProviderWithFileReadStreamCapability> { </ins> const provider = await this.withProvider(resource); <del> if (hasOpenReadWriteCloseCapability(provider) || hasReadWriteCapability(provider) || hasFileReadStreamCapability(provider) || hasFileReadCapability(provider)) { </del> <ins> if (hasOpenReadWriteCloseCapability(provider) || hasReadWriteCapability(provider) || hasFileReadStreamCapability(provider)) { </ins> return provider; } <del> throw new Error(`Filesystem provider for scheme '${resource.scheme}' neither has FileReadWrite, FileReadStream, FileOpenReadWriteClose nor Readonly capability which is needed for the read operation.`); </del> <ins> throw new Error(`Filesystem provider for scheme '${resource.scheme}' neither has FileReadWrite, FileReadStream nor FileOpenReadWriteClose capability which is needed for the read operation.`); </ins> } private async withWriteProvider(resource: URI): Promise<IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithOpenReadWriteCloseCapability> {


return this.doReadFile(provider, resource, options, token); } <del> private async doReadFileAtomic(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithOpenReadWriteCloseCapability | IFileSystemProviderWithFileReadStreamCapability | IFileSystemProviderWithFileReadCapability, resource: URI, options?: IReadFileOptions, token?: CancellationToken): Promise<IFileContent> { </del> <ins> private async doReadFileAtomic(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithOpenReadWriteCloseCapability | IFileSystemProviderWithFileReadStreamCapability, resource: URI, options?: IReadFileOptions, token?: CancellationToken): Promise<IFileContent> { </ins> return new Promise<IFileContent>((resolve, reject) => { this.writeQueue.queueFor(resource, this.getExtUri(provider).providerExtUri).queue(async () => { try {


}); } <del> private async doReadFile(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithOpenReadWriteCloseCapability | IFileSystemProviderWithFileReadStreamCapability | IFileSystemProviderWithFileReadCapability, resource: URI, options?: IReadFileOptions, token?: CancellationToken): Promise<IFileContent> { </del> <ins> private async doReadFile(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithOpenReadWriteCloseCapability | IFileSystemProviderWithFileReadStreamCapability, resource: URI, options?: IReadFileOptions, token?: CancellationToken): Promise<IFileContent> { </ins> const stream = await this.doReadFileStream(provider, resource, { ...options, // optimization: since we know that the caller does not


return this.doReadFileStream(provider, resource, options, token); } <del> private async doReadFileStream(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithOpenReadWriteCloseCapability | IFileSystemProviderWithFileReadStreamCapability | IFileSystemProviderWithFileReadCapability, resource: URI, options?: IReadFileOptions & IReadFileStreamOptions & { preferUnbuffered?: boolean }, token?: CancellationToken): Promise<IFileStreamContent> { </del> <ins> private async doReadFileStream(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithOpenReadWriteCloseCapability | IFileSystemProviderWithFileReadStreamCapability, resource: URI, options?: IReadFileOptions & IReadFileStreamOptions & { preferUnbuffered?: boolean }, token?: CancellationToken): Promise<IFileStreamContent> { </ins> // install a cancellation token that gets cancelled // when any error occurs. this allows us to resolve


return stream; } <del> private readFileUnbuffered(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithFileAtomicReadCapability | IFileSystemProviderWithFileReadCapability, resource: URI, options?: IReadFileOptions & IReadFileStreamOptions): VSBufferReadableStream { </del> <ins> private readFileUnbuffered(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithFileAtomicReadCapability, resource: URI, options?: IReadFileOptions & IReadFileStreamOptions): VSBufferReadableStream { </ins> const stream = newWriteableStream<VSBuffer>(data => VSBuffer.concat(data)); // Read the file into the stream async but do not wait for


return !!(provider.capabilities & FileSystemProviderCapabilities.FileReadStream); } <del> export interface IFileSystemProviderWithFileReadCapability extends IFileSystemProvider { readFile(resource: URI): Promise<Uint8Array>; } export function hasFileReadCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithFileReadCapability { return !!(provider.capabilities & FileSystemProviderCapabilities.Readonly); } </del> export interface IFileSystemProviderWithFileAtomicReadCapability extends IFileSystemProvider { readFile(resource: URI, opts?: IFileAtomicReadOptions): Promise<Uint8Array>; }


import { Disposable, IDisposable } from 'vs/base/common/lifecycle'; import { Event } from 'vs/base/common/event'; import { URI } from 'vs/base/common/uri'; <del> import { FilePermission, FileSystemProviderCapabilities, FileSystemProviderErrorCode, FileType, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadCapability, IStat, IWatchOptions } from 'vs/platform/files/common/files'; </del> <ins> import { FilePermission, FileSystemProviderCapabilities, FileSystemProviderErrorCode, FileType, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IStat, IWatchOptions } from 'vs/platform/files/common/files'; </ins> import { ChangeType, decodeEditSessionFileContent, EDIT_SESSIONS_SCHEME, IEditSessionsStorageService } from 'vs/workbench/contrib/editSessions/common/editSessions'; <ins> import { NotSupportedError } from 'vs/base/common/errors'; </ins> <del> export class EditSessionsFileSystemProvider implements IFileSystemProviderWithFileReadCapability { </del> <ins> export class EditSessionsFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability { </ins> static readonly SCHEMA = EDIT_SESSIONS_SCHEME;


@IEditSessionsStorageService private editSessionsStorageService: IEditSessionsStorageService, ) { } <del> readonly capabilities: FileSystemProviderCapabilities = FileSystemProviderCapabilities.Readonly; </del> <ins> readonly capabilities: FileSystemProviderCapabilities = FileSystemProviderCapabilities.Readonly + FileSystemProviderCapabilities.FileReadWrite; </ins> async readFile(resource: URI): Promise<Uint8Array> { const match = /(?<ref>[^/]+)/(?<folderName>[^/]+)/(?<filePath>.*)/.exec(resource.path.substring(1));


async rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void> { } async delete(resource: URI, opts: IFileDeleteOptions): Promise<void> { } <ins> async writeFile() { throw new NotSupportedError(); } </ins> //#endregion }


} .monaco-workbench .part.editor>.content .gettingStartedContainer .gettingStartedSlide .getting-started-category .codicon.hide-category-button { <del> position: absolute; </del> <ins> margin-left: auto; </ins> top: 4px; right: 8px; }


this.setCountBadge(); // set mergeChanges context <del> commands.executeCommand('setContext', 'git.mergeChanges', merge.map(item => item.resourceUri.toString())); </del> <ins> commands.executeCommand('setContext', 'git.mergeChanges', merge.map(item => item.resourceUri)); </ins> this._onDidChangeStatus.fire();


const outputElement = (prev.firstChild as HTMLElement | null); if (outputElement && outputElement.getAttribute('output-mime-type') === outputInfo.mime) { // same stream <del> const text = outputInfo.text(); const element = document.createElement('span'); </del> <ins> // find child with same id const existing = outputElement.querySelector(`[output-item-id="${outputInfo.id}"]`) as HTMLElement | null; if (existing) { clearContainer(existing); } const text = outputInfo.text(); const element = existing ?? document.createElement('span'); element.classList.add('output-stream'); element.setAttribute('output-item-id', outputInfo.id); </ins> insertOutput(outputInfo.id, [text], ctx.settings.lineLimit, ctx.settings.outputScrolling, element); outputElement.appendChild(element); return;


const element = document.createElement('span'); element.classList.add('output-stream'); <ins> element.setAttribute('output-item-id', outputInfo.id); </ins> const text = outputInfo.text(); insertOutput(outputInfo.id, [text], ctx.settings.lineLimit, ctx.settings.outputScrolling, element);


// Move .zshrc into $ZDOTDIR as the way to activate the script const zdotdir = path.join(os.tmpdir(), `${os.userInfo().username}-vscode-zsh`); envMixin['ZDOTDIR'] = zdotdir; <del> const userZdotdir = env?.ZDOTDIR ?? os.homedir(); </del> <ins> const userZdotdir = env?.ZDOTDIR ?? os.homedir() ?? `~`; </ins> envMixin['USER_ZDOTDIR'] = userZdotdir; const filesToCopy: IShellIntegrationConfigInjection['filesToCopy'] = []; filesToCopy.push({


return URL.createObjectURL(blob); } <del> const result = new URL(scriptPath); COI.addSearchParam(result.searchParams, true, true); result.hash = label; return result.href; </del> <ins> const start = scriptPath.lastIndexOf('?'); const end = scriptPath.lastIndexOf('#', start); const params = start > 0 ? new URLSearchParams(scriptPath.substring(start + 1, ~end ? end : undefined)) : new URLSearchParams(); COI.addSearchParam(params, true, true); const search = params.toString(); if (!search) { return `${scriptPath}#${label}`; } else { return `${scriptPath}?${params.toString()}#${label}`; } </ins> } // ESM-comment-end


private hideTwistiesOfChildlessElements: boolean = false; private shouldRenderIndentGuides: boolean = false; <del> private renderedIndentGuides = new SetMap<ITreeNode<T, TFilterData>, HTMLDivElement>(); </del> private activeIndentNodes = new Set<ITreeNode<T, TFilterData>>(); private indentGuidesDisposable: IDisposable = Disposable.None;


private modelProvider: () => ITreeModel<T, TFilterData, TRef>, onDidChangeCollapseState: Event<ICollapseStateChangeEvent<T, TFilterData>>, private activeNodes: Collection<ITreeNode<T, TFilterData>>, <ins> private renderedIndentGuides: SetMap<ITreeNode<T, TFilterData>, HTMLDivElement>, </ins> options: ITreeRendererOptions = {} ) { this.templateId = renderer.templateId;


const onDidChangeCollapseStateRelay = new Relay<ICollapseStateChangeEvent<T, TFilterData>>(); const onDidChangeActiveNodes = new Relay<ITreeNode<T, TFilterData>[]>(); const activeNodes = this.disposables.add(new EventCollection(onDidChangeActiveNodes.event)); <del> this.renderers = renderers.map(r => new TreeRenderer<T, TFilterData, TRef, any>(r, () => this.model, onDidChangeCollapseStateRelay.event, activeNodes, _options)); </del> <ins> const renderedIndentGuides = new SetMap<ITreeNode<T, TFilterData>, HTMLDivElement>(); this.renderers = renderers.map(r => new TreeRenderer<T, TFilterData, TRef, any>(r, () => this.model, onDidChangeCollapseStateRelay.event, activeNodes, renderedIndentGuides, _options)); </ins> for (const r of this.renderers) { this.disposables.add(r); }


readonly label: string = ''; readonly tooltip: string = ''; <del> readonly class: string = ''; </del> <ins> readonly class: string = 'separator'; </ins> readonly enabled: boolean = false; readonly checked: boolean = false; async run() { }


[ 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> }, );


return; } this.input1View.editor.revealLineInCenter(firstConflict.input1Range.startLineNumber); <ins> transaction(tx => { /** @description setActiveModifiedBaseRange */ viewModel.setActiveModifiedBaseRange(firstConflict, tx); }); </ins> })); }


} ); <ins> public setActiveModifiedBaseRange(range: ModifiedBaseRange | undefined, tx: ITransaction): void { this.manuallySetActiveModifiedBaseRange.set({ range, counter: this.counter++ }, tx); } </ins> public setState( baseRange: ModifiedBaseRange, state: ModifiedBaseRangeState,


const repositoryPath = await window.withProgress( opts, <del> (progress, token) => this.git.clone(url!, { parentPath: parentPath!, progress, recursive: options.recursive }, token) </del> <ins> (progress, token) => this.git.clone(url!, { parentPath: parentPath!, progress, recursive: options.recursive, ref: options.ref }, token) </ins> ); <del> const refToCheckoutAfterClone = options.ref; if (refToCheckoutAfterClone !== undefined) { await window.withProgress( { location: ProgressLocation.Notification, title: localize('checking out ref', "Checking out ref '{0}'...", options.ref) }, async () => { await this.model.openRepository(repositoryPath); const repository = this.model.getRepository(repositoryPath); await repository?.checkout(refToCheckoutAfterClone); }); } </del> const config = workspace.getConfiguration('git'); const openAfterClone = config.get<'always' | 'alwaysNewWindow' | 'whenNoFolderOpen' | 'prompt'>('openAfterClone');


readonly parentPath: string; readonly progress: Progress<{ increment: number }>; readonly recursive?: boolean; <ins> readonly ref?: string; </ins> } export class Git {


if (options.recursive) { command.push('--recursive'); } <ins> if (options.ref) { command.push('--branch', `'${options.ref}'`); } </ins> await this.exec(options.parentPath, command, { cancellationToken, env: { 'GIT_HTTP_USER_AGENT': this.userAgent },


}); this.htmlElements.gutterDiv.style.width = '5px'; <ins> this.htmlElements.root.classList.add(`result`); </ins> this._register( autorunWithStore((reader, store) => {


color: var(--vscode-descriptionForeground); } <ins> .monaco-workbench .merge-editor .code-view.result > .header > .description { display: inline; flex-shrink: 1; } .monaco-workbench .merge-editor .code-view.result > .header > .detail { flex-shrink: 0; } .monaco-workbench .merge-editor .code-view.result > .header > .toolbar { flex-shrink: 0; } </ins> .monaco-workbench .merge-editor .code-view > .header > span.description .codicon { font-size: 14px; color: var(--vscode-descriptionForeground);


if (startLine === endLine) { return undefined; } <del> if (outputMatcher?.length && (endLine - startLine) < outputMatcher.length) { return undefined; } </del> let line: string | undefined; if (outputMatcher?.anchor === 'bottom') { for (let i = endLine - (outputMatcher.offset || 0); i >= startLine; i--) {


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


flex-shrink: 0; } <ins> .monaco-workbench .part > .title > .title-actions .start-debug-action-item .codicon-debug-start { width: 18px; height: 21px; padding-left: 2px; } </ins> .monaco-workbench .monaco-action-bar .start-debug-action-item .configuration .monaco-select-box { border: none; margin-top: 0px;


return; } <del> if (matchesScheme(link, Schemas.command)) { const ret = /command:workbench.action.openLargeOutput?(.*)/.exec(link); if (ret && ret.length === 2) { const outputId = ret[1]; this.openerService.open(CellUri.generateCellOutputUri(this.documentUri, outputId)); return; } console.warn('Command links are deprecated and will be removed, use message passing instead: https://github.com/microsoft/vscode/issues/123601'); } if (matchesScheme(link, Schemas.command)) { if (this.workspaceTrustManagementService.isWorkspaceTrusted()) { this.openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: true }); } else { console.warn('Command links are disabled in untrusted workspaces'); } } else if (matchesSomeScheme(link, Schemas.vscodeNotebookCell, Schemas.http, Schemas.https, Schemas.mailto)) { this.openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: true }); </del> <ins> if (matchesSomeScheme(link, Schemas.vscodeNotebookCell, Schemas.http, Schemas.https, Schemas.mailto)) { this.openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: false }); </ins> } }));


} case 'clicked-link': { let linkToOpen: URI | string | undefined; if (matchesScheme(data.href, Schemas.command)) { <del> const ret = /command:workbench.action.openLargeOutput?(.*)/.exec(data.href); if (ret && ret.length === 2) { const outputId = ret[1]; const group = this.editorGroupService.activeGroup; if (group) { if (group.activeEditor) { group.pinEditor(group.activeEditor); </del> <ins> // We allow a very limited set of commands const uri = URI.parse(data.href); switch (uri.path) { case 'workbench.action.openLargeOutput': { const outputId = uri.query; const group = this.editorGroupService.activeGroup; if (group) { if (group.activeEditor) { group.pinEditor(group.activeEditor); } </ins> } <del> } this.openerService.open(CellUri.generateCellOutputUri(this.documentUri, outputId)); return; </del> <ins> this.openerService.open(CellUri.generateCellOutputUri(this.documentUri, outputId)); return; } case 'github-issues.authNow': case 'workbench.extensions.search': case 'workbench.action.openSettings': { this.openerService.open(data.href, { fromUserGesture: true, allowCommands: true, fromWorkspace: true }); return; } </ins> } <ins> return; </ins> } <del> if (matchesSomeScheme(data.href, Schemas.http, Schemas.https, Schemas.mailto, Schemas.command, Schemas.vscodeNotebookCell, Schemas.vscodeNotebook)) { </del> <ins> if (matchesSomeScheme(data.href, Schemas.http, Schemas.https, Schemas.mailto, Schemas.vscodeNotebookCell, Schemas.vscodeNotebook)) { </ins> linkToOpen = data.href; } else if (!/^[w-]+:/.test(data.href)) { const fragmentStartIndex = data.href.lastIndexOf('#');


} if (linkToOpen) { <del> this.openerService.open(linkToOpen, { fromUserGesture: true, allowCommands: true, fromWorkspace: true }); </del> <ins> this.openerService.open(linkToOpen, { fromUserGesture: true, allowCommands: false, fromWorkspace: true }); </ins> } break; }


import { StartupProfiler } from './startupProfiler'; import { StartupTimings } from './startupTimings'; import { RendererProfiling } from 'vs/workbench/contrib/performance/electron-sandbox/rendererAutoProfiler'; <ins> import { IConfigurationRegistry, Extensions as ConfigExt } from 'vs/platform/configuration/common/configurationRegistry'; import { localize } from 'vs/nls'; </ins> Registry.as<IWorkbenchContributionsRegistry>(Extensions.Workbench).registerWorkbenchContribution(


StartupTimings, LifecyclePhase.Eventually ); <ins> Registry.as<IConfigurationRegistry>(ConfigExt.Configuration).registerConfiguration({ id: 'application', order: 100, type: 'object', 'properties': { 'application.experimental.rendererProfiling': { type: 'boolean', default: false, markdownDescription: localize('experimental.rendererProfiling', "When enabled slow renderers are automatically profiled") } } }); </ins>


import { timeout } from 'vs/base/common/async'; import { generateUuid } from 'vs/base/common/uuid'; <ins> import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; </ins> import { IEnvironmentService } from 'vs/platform/environment/common/environment'; import { ILogService } from 'vs/platform/log/common/log'; import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';


@IEnvironmentService environmentService: IEnvironmentService, @ILogService logService: ILogService, @ITimerService timerService: ITimerService, <ins> @IConfigurationService configService: IConfigurationService </ins> ) { const devOpts = parseExtensionDevOptions(environmentService);


return; } <ins> if (!configService.getValue('application.experimental.rendererProfiling')) { logService.debug(`[perf] SLOW task detected (${maxDuration}ms) but renderer profiling is disabled via 'application.experimental.rendererProfiling'`); return; } </ins> const sessionId = generateUuid(); // start heartbeat monitoring logService.warn(`[perf] Renderer reported VERY LONG TASK (${maxDuration}ms), starting profiling session '${sessionId}'`);


totalTime: sample.totalTime, percentage: sample.percentage, functionName: sample.location, <del> callstack: sample.caller.map(c => `${c.percentage}|${c.location}`).join('<'), extensionId: '' </del> <ins> callstack: sample.caller.map(c => c.location).join('<'), extensionId: '<<renderer>>' </ins> }; this._telemetryService.publicLog2<TelemetrySampleData, TelemetrySampleDataClassification>('prof.freeze.sample', data);


], "action": "comment", "addLabel": "info-needed", <del> "comment": "Thanks for reporting this issue! Unfortunately, it's hard for us to understand what issue you're seeing. Please help us out by providing a screen recording showing exactly what isn't working as expected. While we can work with most standard formats, `.gif` files are preferred as they are displayed inline on GitHub. You may find https://gifcap.dev helpful as a browser-based gif recording tool.nnIf the issue depends on keyboard input, you can help us by enabling screencast mode for the recording (`Developer: Toggle Screencast Mode` in the command palette).nnHappy coding!" </del> <ins> "comment": "Thanks for reporting this issue! Unfortunately, it's hard for us to understand what issue you're seeing. Please help us out by providing a screen recording showing exactly what isn't working as expected. While we can work with most standard formats, `.gif` files are preferred as they are displayed inline on GitHub. You may find https://gifcap.dev helpful as a browser-based gif recording tool.nnIf the issue depends on keyboard input, you can help us by enabling screencast mode for the recording (`Developer: Toggle Screencast Mode` in the command palette). Lastly, please attach this file via the GitHub web interface as emailed responses will strip files out from the issue.nnHappy coding!" </ins> }, { "__comment__": "Allows folks on the team to label issues by commenting: `label My-Label` ",


disturl "https://electronjs.org/headers" <del> target "19.1.8" </del> <ins> target "19.1.9" </ins> runtime "electron" build_from_source "true"


"git": { "name": "chromium", "repositoryUrl": "https://chromium.googlesource.com/chromium/src", <del> "commitHash": "16e28102fdf876ce6d136674ba66343ede07441f" </del> <ins> "commitHash": "a8a8309404d39efa9c624d7aee0e27562721e522" </ins> } }, "licenseDetail": [


"SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." ], "isOnlyProductionDependency": true, <del> "version": "102.0.5005.167" </del> <ins> "version": "102.0.5005.194" </ins> }, { "component": {


}, "isOnlyProductionDependency": true, "license": "MIT", <del> "version": "19.1.8" </del> <ins> "version": "19.1.9" </ins> }, { "component": {


"cssnano": "^4.1.11", "debounce": "^1.0.0", "deemon": "^1.8.0", <del> "electron": "19.1.8", </del> <ins> "electron": "19.1.9", </ins> "eslint": "8.7.0", "eslint-plugin-header": "3.1.1", "eslint-plugin-jsdoc": "^39.3.2",


resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.207.tgz#9c3310ebace2952903d05dcaba8abe3a4ed44c01" integrity sha512-piH7MJDJp4rJCduWbVvmUd59AUne1AFBJ8JaRQvk0KzNTSUnZrVXHCZc+eg+CGE4OujkcLJznhGKD6tuAshj5Q== <del> electron@19.1.8: version "19.1.8" resolved "https://registry.yarnpkg.com/electron/-/electron-19.1.8.tgz#3ce19c270ca86d05bbf0df5ceeaea2d23edc7083" integrity sha512-UfPQdFjgKI0xCm1V5sV3iAVOs0kCwAE91xWzV5tI7ij14yOkxTdXp9BqTzFaSbQYLYxn6q1BUUe1nlzjJjzAnw== </del> <ins> electron@19.1.9: version "19.1.9" resolved "https://registry.yarnpkg.com/electron/-/electron-19.1.9.tgz#01995eea4014f7cdb2f616f5f3492d4ed6f5e4f0" integrity sha512-XT5LkTzIHB+ZtD3dTmNnKjVBWrDWReCKt9G1uAFLz6uJMEVcIUiYO+fph5pLXETiBw/QZBx8egduMEfIccLx+g== </ins> dependencies: "@electron/get" "^1.14.1" "@types/node" "^16.11.26"


*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> .monaco-editor .contentWidgets .codicon-light-bulb, .monaco-editor .contentWidgets .codicon-lightbulb-autofix { </del> <ins> .monaco-editor .lightBulbWidget { </ins> display: flex; align-items: center; justify-content: center; } <del> .monaco-editor .contentWidgets .codicon-light-bulb:hover, .monaco-editor .contentWidgets .codicon-lightbulb-autofix:hover { </del> <ins> .monaco-editor .lightBulbWidget:hover{ </ins> cursor: pointer; } <ins> .monaco-editor .lightBulbWidget.codicon-light-bulb { color: var(--vscode-editorLightBulb-foreground); } .monaco-editor .lightBulbWidget.codicon-lightbulb-autofix { color: var(--vscode-editorLightBulbAutoFix-foreground, var(--vscode-editorLightBulb-foreground)); } .monaco-editor .lightBulbWidget:before { position: relative; z-index: 2; } .monaco-editor .lightBulbWidget:after { position: absolute; top: 0; left: 0; content: ''; display: block; width: 100%; height: 100%; opacity: 0.3; background-color: var(--vscode-editor-background); z-index: 1; } </ins>


import type { CodeActionSet, CodeActionTrigger } from 'vs/editor/contrib/codeAction/common/types'; import * as nls from 'vs/nls'; import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; <del> import { editorBackground, editorLightBulbAutoFixForeground, editorLightBulbForeground } from 'vs/platform/theme/common/colorRegistry'; import { IColorTheme, ICssStyleCollector, registerThemingParticipant } from 'vs/platform/theme/common/themeService'; </del> namespace LightBulbState {


private static readonly _posPref = [ContentWidgetPositionPreference.EXACT]; <del> private readonly _domNode: HTMLDivElement; </del> <ins> private readonly _domNode: HTMLElement; </ins> private readonly _onClick = this._register(new Emitter<{ x: number; y: number; actions: CodeActionSet; trigger: CodeActionTrigger }>()); public readonly onClick = this._onClick.event;


@IKeybindingService keybindingService: IKeybindingService ) { super(); <del> this._domNode = document.createElement('div'); this._domNode.className = Codicon.lightBulb.classNames; </del> <ins> this._domNode = dom.$('div.lightBulbWidget'); </ins> this._register(Gesture.ignoreTarget(this._domNode)); this._editor.addContentWidget(this);


this._domNode.title = value; } } <del> registerThemingParticipant((theme: IColorTheme, collector: ICssStyleCollector) => { const editorBackgroundColor = theme.getColor(editorBackground)?.transparent(0.7); // Lightbulb Icon const editorLightBulbForegroundColor = theme.getColor(editorLightBulbForeground); if (editorLightBulbForegroundColor) { collector.addRule(` .monaco-editor .contentWidgets ${Codicon.lightBulb.cssSelector} { color: ${editorLightBulbForegroundColor}; background-color: ${editorBackgroundColor}; }`); } // Lightbulb Auto Fix Icon const editorLightBulbAutoFixForegroundColor = theme.getColor(editorLightBulbAutoFixForeground); if (editorLightBulbAutoFixForegroundColor) { collector.addRule(` .monaco-editor .contentWidgets ${Codicon.lightbulbAutofix.cssSelector} { color: ${editorLightBulbAutoFixForegroundColor}; background-color: ${editorBackgroundColor}; }`); } }); </del>


# This makes sure the model is included in the package !@vscode/vscode-languagedetection/model/** <ins> # Ensure only the required telemetry pieces are loaded in web to reduce bundle size @microsoft/1ds-core-js/** @microsoft/1ds-post-js/** @microsoft/applicationinsights-core-js/** @microsoft/applicationinsights-shims/** !@microsoft/1ds-core-js/dist/ms.core.min.js !@microsoft/1ds-post-js/dist/ms.post.min.js !@microsoft/applicationinsights-core-js/browser/applicationinsights-core-js.min.js !@microsoft/applicationinsights-shims/dist/umd/applicationinsights-shims.min.js </ins>


"pickerGroup.foreground": "#75715E", "input.background": "#414339", "inputOption.activeBorder": "#75715E", <del> "focusBorder": "#75715E", </del> <ins> "focusBorder": "#99947c", </ins> "editorWidget.background": "#1e1f1c", "debugToolBar.background": "#1e1f1c", "diffEditor.insertedTextBackground": "#4b661680", // middle of #272822 and #a6e22e


} ], "colors": { <del> "focusBorder": "#A6B39B", </del> <ins> "focusBorder": "#9769dc", </ins> "pickerGroup.foreground": "#A6B39B", "pickerGroup.border": "#749351", "list.activeSelectionForeground": "#6c6c6c",


"colors": { // Base // "foreground": "", <del> "focusBorder": "#D3AF86", </del> <ins> "focusBorder": "#b49471", </ins> // "contrastActiveBorder": "", // "contrastBorder": "", // "widget.shadow": "",


const handleTitleClickOrTouch = (e: MouseEvent | GestureEvent): void => { let target: HTMLElement; if (e instanceof MouseEvent) { <del> if (e.button !== 0 || (isMacintosh && e.ctrlKey)) { return undefined; // only for left mouse click (ctrl+click on macos is right-click) </del> <ins> if (e.button !== 0 /* middle/right mouse button */ || (isMacintosh && e.ctrlKey /* macOS context menu */)) { return undefined; </ins> } target = e.target as HTMLElement;


const handleClickOrTouch = (e: MouseEvent | GestureEvent, preserveFocus: boolean): void => { tab.blur(); // prevent flicker of focus outline on tab until editor got focus <del> if (e instanceof MouseEvent && e.button !== 0) { </del> <ins> if (e instanceof MouseEvent && (e.button !== 0 /* middle/right mouse button */ || (isMacintosh && e.ctrlKey /* macOS context menu */))) { </ins> if (e.button === 1) { e.preventDefault(); // required to prevent auto-scrolling (https://github.com/microsoft/vscode/issues/16690) } <del> return undefined; // only for left mouse click </del> <ins> return undefined; </ins> } if (this.originatesFromTabActionBar(e)) {


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


private _tokenizeString(text: string, engine: MarkdownIt) { this._resetSlugCount(); <del> return engine.parse(text.replace(UNICODE_NEWLINE_REGEX, ''), {}); </del> <ins> return engine.parse(text, {}); </ins> } private _resetSlugCount(): void {


maxHeight = Math.min(maxHeight, this._hover.containerDomNode.clientHeight); this._hover.containerDomNode.style.maxHeight = `${maxHeight}px`; <ins> if (this._hover.contentsDomNode.clientHeight > maxHeight) { this._hover.contentsDomNode.style.height = `${maxHeight}px`; } if (this._hover.contentsDomNode.clientHeight < this._hover.contentsDomNode.scrollHeight) { // Add padding for a vertical scrollbar const extraRightPadding = `${this._hover.scrollbar.options.verticalScrollbarSize}px`; if (this._hover.contentsDomNode.style.paddingRight !== extraRightPadding) { this._hover.contentsDomNode.style.paddingRight = extraRightPadding; } } </ins> } private setHoverPointerPosition(target: TargetRect): void {


/* Must be higher than sash's z-index and terminal canvases */ z-index: 40; overflow: hidden; <del> overflow-y: auto; </del> max-width: 700px; }


constructor() { super({ id: 'workbench.action.openWalkthrough', <del> title: { value: localize('miGetStarted', "Get Started"), original: 'Get Started' }, </del> <ins> title: { value: localize('miWelcome', "Welcome"), original: 'Welcome' }, </ins> category: Categories.Help, f1: true, menu: {


EditorPaneDescriptor.create( GettingStartedPage, GettingStartedPage.ID, <del> localize('getStarted', "Get Started") </del> <ins> localize('welcome', "Welcome") </ins> ), [ new SyncDescriptor(GettingStartedInput) ] ); <del> const category = { value: localize('getStarted', "Get Started"), original: 'Get Started' }; </del> <ins> const category = { value: localize('welcome', "Welcome"), original: 'Welcome' }; </ins> registerAction2(class extends Action2 { constructor() {


this.categoriesSlide = $('.gettingStartedSlideCategories.gettingStartedSlide'); <del> const prevButton = $('button.prev-button.button-link', { 'x-dispatch': 'scrollPrev' }, $('span.scroll-button.codicon.codicon-chevron-left'), $('span.moreText', {}, localize('getStarted', "Get Started"))); </del> <ins> const prevButton = $('button.prev-button.button-link', { 'x-dispatch': 'scrollPrev' }, $('span.scroll-button.codicon.codicon-chevron-left'), $('span.moreText', {}, localize('welcome', "Welcome"))); </ins> this.stepsSlide = $('.gettingStartedSlideDetails.gettingStartedSlide', {}, prevButton); this.stepsContent = $('.gettingStartedDetailsContent', {});


// Seprate from main module to break dependency cycles between welcomePage and gettingStarted. export const welcomePageBackground = registerColor('welcomePage.background', { light: null, dark: null, hcDark: null, hcLight: null }, localize('welcomePage.background', 'Background color for the Welcome page.')); <del> export const welcomePageTileBackground = registerColor('welcomePage.tileBackground', { dark: editorWidgetBackground, light: editorWidgetBackground, hcDark: '#000', hcLight: editorWidgetBackground }, localize('welcomePage.tileBackground', 'Background color for the tiles on the Get Started page.')); export const welcomePageTileHoverBackground = registerColor('welcomePage.tileHoverBackground', { dark: lighten(editorWidgetBackground, .2), light: darken(editorWidgetBackground, .1), hcDark: null, hcLight: null }, localize('welcomePage.tileHoverBackground', 'Hover background color for the tiles on the Get Started.')); export const welcomePageTileBorder = registerColor('welcomePage.tileBorder', { dark: '#ffffff1a', light: '#0000001a', hcDark: contrastBorder, hcLight: contrastBorder }, localize('welcomePage.tileBorder', 'Border color for the tiles on the Get Started page.')); </del> <ins> export const welcomePageTileBackground = registerColor('welcomePage.tileBackground', { dark: editorWidgetBackground, light: editorWidgetBackground, hcDark: '#000', hcLight: editorWidgetBackground }, localize('welcomePage.tileBackground', 'Background color for the tiles on the Welcome page.')); export const welcomePageTileHoverBackground = registerColor('welcomePage.tileHoverBackground', { dark: lighten(editorWidgetBackground, .2), light: darken(editorWidgetBackground, .1), hcDark: null, hcLight: null }, localize('welcomePage.tileHoverBackground', 'Hover background color for the tiles on the Welcome.')); export const welcomePageTileBorder = registerColor('welcomePage.tileBorder', { dark: '#ffffff1a', light: '#0000001a', hcDark: contrastBorder, hcLight: contrastBorder }, localize('welcomePage.tileBorder', 'Border color for the tiles on the Welcome page.')); </ins> export const welcomePageProgressBackground = registerColor('welcomePage.progress.background', { light: inputBackground, dark: inputBackground, hcDark: inputBackground, hcLight: inputBackground }, localize('welcomePage.progress.background', 'Foreground color for the Welcome page progress bars.'));


} override getName() { <del> return localize('getStarted', "Get Started"); </del> <ins> return localize('getStarted', "Welcome"); </ins> } selectedCategory: string | undefined;


* Mark the end of the keydown event. */ function markKeyDownEnd() { <del> performance.mark('keydown/end'); state.keydown = EventPhase.Finished; </del> <ins> if (state.keydown === EventPhase.InProgress) { performance.mark('keydown/end'); state.keydown = EventPhase.Finished; } </ins> } /**


* Record the start of the input event. */ export function onInput() { <ins> if (state.input === EventPhase.Before) { // it looks like we didn't receive a `beforeinput` onBeforeInput(); } </ins> queueMicrotask(markInputEnd); } function markInputEnd() { <del> performance.mark('input/end'); state.input = EventPhase.Finished; </del> <ins> if (state.input === EventPhase.InProgress) { performance.mark('input/end'); state.input = EventPhase.Finished; } </ins> } /**


* Mark the end of the animation frame performing the rendering. */ function markRenderEnd() { <del> performance.mark('render/end'); state.render = EventPhase.Finished; </del> <ins> if (state.render === EventPhase.InProgress) { performance.mark('render/end'); state.render = EventPhase.Finished; } </ins> } function scheduleRecordIfFinishedTask() {


return this._scrollBeyondLastLine && !this.isEmbedded; } <del> layout(dimension: DOM.Dimension, shadowElement?: HTMLElement, position?: DOM.IDomPosition): void { </del> <ins> layout(dimension: DOM.Dimension, shadowElement?: HTMLElement, _position?: DOM.IDomPosition): void { </ins> if (!shadowElement && this._shadowElementViewInfo === null) { this._dimension = dimension; return;


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


this._overlayContainer.style.position = 'absolute'; this._overlayContainer.style.overflow = 'hidden'; <del> this.layoutContainerOverShadowElement(dimension, position); </del> <ins> this.layoutContainerOverShadowElement(dimension, /*position*/ undefined); </ins> if (this._webviewTransparentCover) { this._webviewTransparentCover.style.height = `${dimension.height}px`;


this._disposables.push( vscode.commands.registerCommand('references-view.next', () => this.next(false)), vscode.commands.registerCommand('references-view.prev', () => this.previous(false)), <ins> _view.onDidChangeSelection(() => this._ensureSelectedElementIsVisible()), </ins> ); }


this._ctxCanNavigate.set(Boolean(this._delegate)); } <ins> private _ensureSelectedElementIsVisible(): void { if (this._view.selection.length === 0) { return; } const [item] = this._view.selection; const location = this._delegate?.location(item); if (!location) { return; } if (vscode.window.activeTextEditor?.document.uri.toString() !== location.uri.toString()) { this._open(location, true); } } </ins> private _anchor(): undefined | unknown { if (!this._delegate) { return undefined;


} location(item: FileItem | ReferenceItem) { <del> return item instanceof ReferenceItem ? item.location : undefined; </del> <ins> return item instanceof ReferenceItem ? item.location : new vscode.Location(item.uri, item.references[0]?.location.range ?? new vscode.Position(0, 0)); </ins> } nearest(uri: vscode.Uri, position: vscode.Position): FileItem | ReferenceItem | undefined {


return false; // resource must not be pending to save } <del> if (this.filesConfigurationService.getAutoSaveMode() === AutoSaveMode.AFTER_SHORT_DELAY && !fileModel?.hasState(TextFileEditorModelState.ERROR)) { </del> <ins> if (resource.scheme !== Schemas.untitled && this.filesConfigurationService.getAutoSaveMode() === AutoSaveMode.AFTER_SHORT_DELAY && !fileModel?.hasState(TextFileEditorModelState.ERROR)) { </ins> // leave models auto saved after short delay unless <del> // the save resulted in an error </del> <ins> // the save resulted in an error and not for untitled // that are not auto-saved anyway </ins> return false; }


} } <del> test('dirty untitled text file model opens as editor', async function () { const accessor = await createTracker(); </del> <ins> test('dirty untitled text file model opens as editor', function () { return testUntitledEditor(false); }); test('dirty untitled text file model opens as editor - autosave ON', function () { return testUntitledEditor(true); }); async function testUntitledEditor(autoSaveEnabled: boolean): Promise<void> { const accessor = await createTracker(autoSaveEnabled); </ins> const untitledTextEditor = await accessor.textEditorService.resolveTextEditor({ resource: undefined, forceUntitled: true }) as UntitledTextEditorInput; const model = disposables.add(await untitledTextEditor.resolve());


await awaitEditorOpening(accessor.editorService); assert.ok(accessor.editorService.isOpened(untitledTextEditor)); <del> }); </del> <ins> } </ins> function awaitEditorOpening(editorService: IEditorService): Promise<void> { return Event.toPromise(Event.once(editorService.onDidActiveEditorChange));


@ILabelService private readonly _labelService: ILabelService ) { super(); <ins> for (const commandSelector of this._terminalContributionService.quickFixes) { this.registerCommandSelector(commandSelector); } </ins> const commandDetectionCapability = this._capabilities.get(TerminalCapability.CommandDetection); if (commandDetectionCapability) { this._registerCommandHandlers();


} }); } <del> for (const commandSelector of this._terminalContributionService.quickFixes) { this.registerCommandSelector(commandSelector); } </del> this._quickFixService.onDidRegisterProvider(result => this.registerCommandFinishedListener(convertToQuickFixOptions(result))); this._quickFixService.onDidUnregisterProvider(id => this._commandListeners.delete(id)); }


get providers(): Map<string, ITerminalQuickFixProvider> { return this._providers; } constructor(@ITerminalContributionService private readonly _terminalContributionService: ITerminalContributionService) { <del> for (const selector of this._terminalContributionService.quickFixes) { this.registerCommandSelector(selector); } </del> <ins> this._terminalContributionService.quickFixes.then(selectors => { for (const selector of selectors) { this.registerCommandSelector(selector); } }); </ins> } registerCommandSelector(selector: ITerminalCommandSelector): void {


})); } this._register(this._quickFixService.onDidRegisterProvider(result => this.registerCommandFinishedListener(convertToQuickFixOptions(result)))); <del> for (const selector of terminalContributionService.quickFixes) { this.registerCommandSelector(selector); } </del> <ins> terminalContributionService.quickFixes.then(quickFixSelectors => { for (const selector of quickFixSelectors) { this.registerCommandSelector(selector); } }); </ins> this._register(this._quickFixService.onDidRegisterCommandSelector(selector => this.registerCommandSelector(selector))); this._register(this._quickFixService.onDidUnregisterProvider(id => this._commandListeners.delete(id))); }


readonly _serviceBrand: undefined; readonly terminalProfiles: ReadonlyArray<IExtensionTerminalProfile>; <del> readonly quickFixes: Array<ITerminalCommandSelector>; </del> <ins> readonly quickFixes: Promise<Array<ITerminalCommandSelector>>; </ins> } export const ITerminalContributionService = createDecorator<ITerminalContributionService>('terminalContributionsService');


private _terminalProfiles: ReadonlyArray<IExtensionTerminalProfile> = []; get terminalProfiles() { return this._terminalProfiles; } <del> private _quickFixes: Array<ITerminalCommandSelector> = []; get quickFixes() { return this._quickFixes; } </del> <ins> quickFixes: Promise<Array<ITerminalCommandSelector>>; </ins> constructor() { <del> terminalsExtPoint.setHandler(contributions => { </del> <ins> this.quickFixes = new Promise((r) => terminalsExtPoint.setHandler(contributions => { </ins> this._terminalProfiles = contributions.map(c => { return c.value?.profiles?.filter(p => hasValidTerminalIcon(p)).map(e => { return { ...e, extensionIdentifier: c.description.identifier.value }; }) || []; }).flat(); <del> this._quickFixes = (contributions.filter(c => isProposedApiEnabled(c.description, 'terminalQuickFixProvider')).map(c => c.value.quickFixes ? c.value.quickFixes.map(fix => { return { ...fix, extensionIdentifier: c.description.identifier.value }; }) : [])).flat(); }); </del> <ins> const quickFixes = (contributions.filter(c => isProposedApiEnabled(c.description, 'terminalQuickFixProvider')).map(c => c.value.quickFixes ? c.value.quickFixes.map(fix => { return { ...fix, extensionIdentifier: c.description.identifier.value }; }) : [])).flat(); r(quickFixes); })); </ins> } }


rows: 30 }); instantiationService.stub(IStorageService, new TestStorageService()); <del> instantiationService.stub(ITerminalContributionService, { quickFixes: [] } as Partial<ITerminalContributionService>); </del> <ins> instantiationService.stub(ITerminalContributionService, { quickFixes: new Promise((r) => { r([]); }) } as Partial<ITerminalContributionService>); </ins> instantiationService.stub(ITerminalQuickFixService, { onDidRegisterProvider: new Emitter().event, onDidUnregisterProvider: new Emitter().event, onDidRegisterCommandSelector: new Emitter().event } as Partial<ITerminalQuickFixService>); instantiationService.stub(IConfigurationService, new TestConfigurationService()); instantiationService.stub(ILabelService, {} as Partial<ILabelService>);


class TestTerminalContributionService implements ITerminalContributionService { _serviceBrand: undefined; terminalProfiles: readonly IExtensionTerminalProfile[] = []; <del> quickFixes: ITerminalCommandSelector[] = []; </del> <ins> quickFixes: Promise<ITerminalCommandSelector[]> = new Promise((r) => { r([]); }); </ins> setProfiles(profiles: IExtensionTerminalProfile[]): void { this.terminalProfiles = profiles; }


import { ITerminalContributionService } from 'vs/workbench/contrib/terminal/common/terminalExtensionPoints'; export class TerminalQuickFixService implements ITerminalQuickFixService { <ins> declare _serviceBrand: undefined; private _selectors: Map<string, ITerminalCommandSelector> = new Map(); private _providers: Map<string, ITerminalQuickFixProvider> = new Map(); get providers(): Map<string, ITerminalQuickFixProvider> { return this._providers; } </ins> private readonly _onDidRegisterProvider = new Emitter<ITerminalQuickFixProviderSelector>(); readonly onDidRegisterProvider = this._onDidRegisterProvider.event; private readonly _onDidRegisterCommandSelector = new Emitter<ITerminalCommandSelector>(); readonly onDidRegisterCommandSelector = this._onDidRegisterCommandSelector.event; private readonly _onDidUnregisterProvider = new Emitter<string>(); readonly onDidUnregisterProvider = this._onDidUnregisterProvider.event; <del> _serviceBrand: undefined; _providers: Map<string, ITerminalQuickFixProvider> = new Map(); _selectors: Map<string, ITerminalCommandSelector> = new Map(); get providers(): Map<string, ITerminalQuickFixProvider> { return this._providers; } </del> constructor(@ITerminalContributionService private readonly _terminalContributionService: ITerminalContributionService) { this._terminalContributionService.quickFixes.then(selectors => {


} registerQuickFixProvider(id: string, provider: ITerminalQuickFixProvider): IDisposable { <del> this._providers.set(id, provider); const selector = this._selectors.get(id); if (!selector) { throw new Error(`No registered selector for ID: ${id}`); } this._onDidRegisterProvider.fire({ selector, provider }); </del> <ins> // This is more complicated than it looks like it should be because we need to return an // IDisposable synchronously but we must await ITerminalContributionService.quickFixes // asynchronously before actually registering the provider. let disposed = false; this._terminalContributionService.quickFixes.then(() => { if (disposed) { return; } this._providers.set(id, provider); const selector = this._selectors.get(id); if (!selector) { throw new Error(`No registered selector for ID: ${id}`); } this._onDidRegisterProvider.fire({ selector, provider }); }); </ins> return toDisposable(() => { <del> this._selectors.delete(id); </del> <ins> disposed = true; </ins> this._providers.delete(id); <del> this._onDidUnregisterProvider.fire(selector.id); </del> <ins> const selector = this._selectors.get(id); if (selector) { this._selectors.delete(id); this._onDidUnregisterProvider.fire(selector.id); } </ins> }); } }


readonly persistentProcessId: number | undefined; /** <del> * The id of a persistent process during the shutdown process */ shutdownPersistentProcessId: number | undefined; /** </del> * Whether the process should be persisted across reloads. */ readonly shouldPersist: boolean;


import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; import { IShellLaunchConfig, TerminalExitReason, TerminalLocation, TerminalSettingId } from 'vs/platform/terminal/common/terminal'; import { IEditorGroup } from 'vs/workbench/services/editor/common/editorGroupsService'; <del> import { ILifecycleService } from 'vs/workbench/services/lifecycle/common/lifecycle'; </del> <ins> import { ILifecycleService, ShutdownReason, WillShutdownEvent } from 'vs/workbench/services/lifecycle/common/lifecycle'; </ins> import { ConfirmOnKill } from 'vs/workbench/contrib/terminal/common/terminal'; import { IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration';


// Don't dispose editor when instance is torn down on shutdown to avoid extra work and so // the editor/tabs don't disappear <del> this._lifecycleService.onWillShutdown(() => { </del> <ins> this._lifecycleService.onWillShutdown((e: WillShutdownEvent) => { </ins> this._isShuttingDown = true; dispose(disposeListeners); <ins> // Don't touch processes if the shutdown was a result of reload as they will be reattached const shouldPersistTerminals = this._configurationService.getValue<boolean>(TerminalSettingId.EnablePersistentSessions) && e.reason === ShutdownReason.RELOAD; if (shouldPersistTerminals) { instance.detachProcessAndDispose(TerminalExitReason.Shutdown); } else { instance.dispose(TerminalExitReason.Shutdown); } </ins> }); }


readonly _processManager: ITerminalProcessManager; private readonly _resource: URI; <del> private _shutdownPersistentProcessId: number | undefined; </del> // Enables disposal of the xterm onKey // event when the CwdDetection capability // is added


return TerminalInstance._lastKnownCanvasDimensions; } <del> set shutdownPersistentProcessId(shutdownPersistentProcessId: number | undefined) { this._shutdownPersistentProcessId = shutdownPersistentProcessId; } get persistentProcessId(): number | undefined { return this._processManager.persistentProcessId ?? this._shutdownPersistentProcessId; } get shouldPersist(): boolean { return (this._processManager.shouldPersist || this._shutdownPersistentProcessId !== undefined) && !this.shellLaunchConfig.isTransient && (!this.reconnectionProperties || this._configurationService.getValue(TaskSettingId.Reconnection) === true); } </del> <ins> get persistentProcessId(): number | undefined { return this._processManager.persistentProcessId; } get shouldPersist(): boolean { return this._processManager.shouldPersist && !this.shellLaunchConfig.isTransient && (!this.reconnectionProperties || this._configurationService.getValue(TaskSettingId.Reconnection) === true); } </ins> /** * Create xterm.js instance and attach data listeners.


// Don't touch processes if the shutdown was a result of reload as they will be reattached const shouldPersistTerminals = this._configHelper.config.enablePersistentSessions && e.reason === ShutdownReason.RELOAD; if (shouldPersistTerminals) { <del> for (const instance of this.instances) { </del> <ins> for (const instance of this._terminalGroupService.instances) { </ins> instance.detachProcessAndDispose(TerminalExitReason.Shutdown); } return; } <del> // Force dispose of all terminal instances const shouldPersistTerminalsForEvent = this._shouldReviveProcesses(e.reason); for (const instance of this.instances) { if (shouldPersistTerminalsForEvent) { instance.shutdownPersistentProcessId = instance.persistentProcessId; } </del> <ins> // Force dispose of all pane terminal instances for (const instance of this._terminalGroupService.instances) { </ins> instance.dispose(TerminalExitReason.Shutdown); }


this._editorContainer.style.height = `${editorHeight}px`; this._register(this._editor.onDidContentSizeChange((e) => { <ins> if (this._editorLayoutInProgress) { return; } </ins> if (e.contentHeightChanged && this.cell.layoutInfo.editorHeight !== e.contentHeight) { this.cell.editorHeight = e.contentHeight; }


const editorViewState = this.cell.getSourceEditorViewState() as editorCommon.IDiffEditorViewState | null; if (editorViewState) { <del> console.log('restore view state', this.cell.modified.handle, editorViewState); </del> this._editor!.restoreViewState(editorViewState); }


this.cell.editorHeight = contentHeight; } <ins> private _editorLayoutInProgress = false; </ins> layout(state: IDiffElementLayoutState) { DOM.scheduleAtNextAnimationFrame(() => { <ins> this._editorLayoutInProgress = true; </ins> if (state.editorHeight) { this._editorContainer.style.height = `${this.cell.layoutInfo.editorHeight}px`; this._editor!.layout({


} <ins> this._editorLayoutInProgress = false; </ins> this.layoutNotebookCell(); }); }


const workbenchRegistry = Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench); workbenchRegistry.registerWorkbenchContribution(ExtensionsContributions, LifecyclePhase.Restored); <del> workbenchRegistry.registerWorkbenchContribution(StatusUpdater, LifecyclePhase.Restored); </del> <ins> workbenchRegistry.registerWorkbenchContribution(StatusUpdater, LifecyclePhase.Eventually); </ins> workbenchRegistry.registerWorkbenchContribution(MaliciousExtensionChecker, LifecyclePhase.Eventually); workbenchRegistry.registerWorkbenchContribution(KeymapExtensions, LifecyclePhase.Restored); workbenchRegistry.registerWorkbenchContribution(ExtensionsViewletViewsContribution, LifecyclePhase.Restored);


@IWorkbenchExtensionEnablementService private readonly extensionEnablementService: IWorkbenchExtensionEnablementService ) { super(); <ins> this.onServiceChange(); </ins> this._register(Event.debounce(extensionsWorkbenchService.onChange, () => undefined, 100, undefined, undefined, this._store)(this.onServiceChange, this)); }


this._register(this.storageService.onDidChangeValue(e => this.onDidChangeStorage(e))); } private _reportTelemetry() { const extensionIds = this.installed.filter(extension => !extension.isBuiltin &&


return nls.localize('postUpdateTooltip', "Please reload Visual Studio Code to enable the updated extension."); } <del> const extensionInOtherServer = this.installed.filter(e => areSameExtensions(e.identifier, extension!.identifier) && e.server !== extension!.server)[0]; if (extensionInOtherServer) { // This extension prefers to run on UI/Local side but is running in remote if (runningExtensionServer === this.extensionManagementServerService.remoteExtensionManagementServer && this.extensionManifestPropertiesService.prefersExecuteOnUI(extension.local!.manifest) && extensionInOtherServer.server === this.extensionManagementServerService.localExtensionManagementServer) { return nls.localize('enable locally', "Please reload Visual Studio Code to enable this extension locally."); } </del> <ins> if (this.extensionsServers.length > 1) { const extensionInOtherServer = this.installed.filter(e => areSameExtensions(e.identifier, extension!.identifier) && e.server !== extension!.server)[0]; if (extensionInOtherServer) { // This extension prefers to run on UI/Local side but is running in remote if (runningExtensionServer === this.extensionManagementServerService.remoteExtensionManagementServer && this.extensionManifestPropertiesService.prefersExecuteOnUI(extension.local!.manifest) && extensionInOtherServer.server === this.extensionManagementServerService.localExtensionManagementServer) { return nls.localize('enable locally', "Please reload Visual Studio Code to enable this extension locally."); } </ins> <del> // This extension prefers to run on Workspace/Remote side but is running in local if (runningExtensionServer === this.extensionManagementServerService.localExtensionManagementServer && this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(extension.local!.manifest) && extensionInOtherServer.server === this.extensionManagementServerService.remoteExtensionManagementServer) { return nls.localize('enable remote', "Please reload Visual Studio Code to enable this extension in {0}.", this.extensionManagementServerService.remoteExtensionManagementServer?.label); </del> <ins> // This extension prefers to run on Workspace/Remote side but is running in local if (runningExtensionServer === this.extensionManagementServerService.localExtensionManagementServer && this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(extension.local!.manifest) && extensionInOtherServer.server === this.extensionManagementServerService.remoteExtensionManagementServer) { return nls.localize('enable remote', "Please reload Visual Studio Code to enable this extension in {0}.", this.extensionManagementServerService.remoteExtensionManagementServer?.label); } </ins> } }