 /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ // eslint-disable-next-line local/code-import-patterns import assert from 'assert'; // eslint-disable-next-line local/code-import-patterns import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js'; import { IssueReporterModel } from '../issueReporterModel.js'; import { IssueType } from '../../common/issue.js'; import { normalizeGitHubUrl } from '../../common/issueReporterUtil.js'; suite('IssueReporter', () => { ensureNoDisposablesAreLeakedInTestSuite(); test('sets defaults to include all data', () => { const issueReporterModel = new IssueReporterModel(); assert.deepStrictEqual(issueReporterModel.getData(), { allExtensions: [], includeSystemInfo: true, includeExtensionData: true, includeWorkspaceInfo: true, includeProcessInfo: true, includeExtensions: true, includeExperiments: true, issueType: 0 }); }); test('serializes model skeleton when no data is provided', () => { const issueReporterModel = new IssueReporterModel({}); assert.strictEqual(issueReporterModel.serialize(), ` Type: <b>Bug</b> undefined VS Code version: undefined OS version: undefined Modes: Extensions: none <!-- generated by issue reporter -->`); }); test('serializes GPU information when data is provided', () => { const issueReporterModel = new IssueReporterModel({ issueType: 0, systemInfo: { os: 'Darwin', cpus: 'Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz (8 x 2800)', memory: '16.00GB', vmHint: '0%', processArgs: '', screenReader: 'no', remoteData: [], gpuStatus: { '2d_canvas': 'enabled', 'checker_imaging': 'disabled_off' } } }); assert.strictEqual(issueReporterModel.serialize(), ` Type: Bug undefined VS Code version: undefined OS version: undefined Modes:  System Info |Item|Value| |---|---| |CPUs|Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz (8 x 2800)| |GPU Status|2d_canvas: enabled
checker_imaging: disabled_off| |Load (avg)|undefined| |Memory (System)|16.00GB| |Process Argv|| |Screen Reader|no| |VM|0%| Extensions: none `); }); test('serializes experiment info when data is provided', () => { const issueReporterModel = new IssueReporterModel({ issueType: 0, systemInfo: { os: 'Darwin', cpus: 'Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz (8 x 2800)', memory: '16.00GB', vmHint: '0%', processArgs: '', screenReader: 'no', remoteData: [], gpuStatus: { '2d_canvas': 'enabled', 'checker_imaging': 'disabled_off' } }, experimentInfo: 'vsliv695:30137379nvsins829:30139715' }); assert.strictEqual(issueReporterModel.serialize(), ` Type: Bug undefined VS Code version: undefined OS version: undefined Modes:  System Info |Item|Value| |---|---| |CPUs|Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz (8 x 2800)| |GPU Status|2d_canvas: enabled
checker_imaging: disabled_off| |Load (avg)|undefined| |Memory (System)|16.00GB| |Process Argv|| |Screen Reader|no| |VM|0%| Extensions: none A/B Experiments ``` vsliv695:30137379 vsins829:30139715 ```  `); }); test('serializes Linux environment information when data is provided', () => { const issueReporterModel = new IssueReporterModel({ issueType: 0, systemInfo: { os: 'Darwin', cpus: 'Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz (8 x 2800)', memory: '16.00GB', vmHint: '0%', processArgs: '', screenReader: 'no', remoteData: [], gpuStatus: {}, linuxEnv: { desktopSession: 'ubuntu', xdgCurrentDesktop: 'ubuntu', xdgSessionDesktop: 'ubuntu:GNOME', xdgSessionType: 'x11' } } }); assert.strictEqual(issueReporterModel.serialize(), ` Type: Bug undefined VS Code version: undefined OS version: undefined Modes:  System Info |Item|Value| |---|---| |CPUs|Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz (8 x 2800)| |GPU Status|| |Load (avg)|undefined| |Memory (System)|16.00GB| |Process Argv|| |Screen Reader|no| |VM|0%| |DESKTOP_SESSION|ubuntu| |XDG_CURRENT_DESKTOP|ubuntu| |XDG_SESSION_DESKTOP|ubuntu:GNOME| |XDG_SESSION_TYPE|x11| Extensions: none `); }); test('serializes remote information when data is provided', () => { const issueReporterModel = new IssueReporterModel({ issueType: 0, systemInfo: { os: 'Darwin', cpus: 'Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz (8 x 2800)', memory: '16.00GB', vmHint: '0%', processArgs: '', screenReader: 'no', gpuStatus: { '2d_canvas': 'enabled', 'checker_imaging': 'disabled_off' }, remoteData: [ { hostName: 'SSH: Pineapple', machineInfo: { os: 'Linux x64 4.18.0', cpus: 'Intel(R) Xeon(R) CPU E5-2673 v4 @ 2.30GHz (2 x 2294)', memory: '8GB', vmHint: '100%' } } ] } }); assert.strictEqual(issueReporterModel.serialize(), ` Type: Bug undefined VS Code version: undefined OS version: undefined Modes: Remote OS version: Linux x64 4.18.0  System Info |Item|Value| |---|---| |CPUs|Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz (8 x 2800)| |GPU Status|2d_canvas: enabled
checker_imaging: disabled_off| |Load (avg)|undefined| |Memory (System)|16.00GB| |Process Argv|| |Screen Reader|no| |VM|0%| |Item|Value| |---|---| |Remote|SSH: Pineapple| |OS|Linux x64 4.18.0| |CPUs|Intel(R) Xeon(R) CPU E5-2673 v4 @ 2.30GHz (2 x 2294)| |Memory (System)|8GB| |VM|100%| Extensions: none `); }); test('escapes backslashes in processArgs', () => { const issueReporterModel = new IssueReporterModel({ issueType: 0, systemInfo: { os: 'Darwin', cpus: 'Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz (8 x 2800)', memory: '16.00GB', vmHint: '0%', processArgs: 'HOSTpath', screenReader: 'no', remoteData: [], gpuStatus: {} } }); assert.strictEqual(issueReporterModel.serialize(), ` Type: Bug undefined VS Code version: undefined OS version: undefined Modes:  System Info |Item|Value| |---|---| |CPUs|Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz (8 x 2800)| |GPU Status|| |Load (avg)|undefined| |Memory (System)|16.00GB| |Process Argv|HOSTpath| |Screen Reader|no| |VM|0%| Extensions: none `); }); test('should supply mode if applicable', () => { const issueReporterModel = new IssueReporterModel({ isUnsupported: true, restrictedMode: true }); assert.strictEqual(issueReporterModel.serialize(), ` Type: <b>Bug</b> undefined VS Code version: undefined OS version: undefined Modes: Restricted, Unsupported Extensions: none <!-- generated by issue reporter -->`); }); test('should normalize GitHub urls', () => { [ 'https://github.com/repo', 'https://github.com/repo/', 'https://github.com/repo.git', 'https://github.com/repo/issues', 'https://github.com/repo/issues/', 'https://github.com/repo/issues/new', 'https://github.com/repo/issues/new/' ].forEach(url => { assert.strictEqual('https://github.com/repo', normalizeGitHubUrl(url)); }); }); test('should have support for filing on extensions for bugs, performance issues, and feature requests', () => { [ IssueType.Bug, IssueType.FeatureRequest, IssueType.PerformanceIssue ].forEach(type => { const issueReporterModel = new IssueReporterModel({ issueType: type, fileOnExtension: true }); assert.strictEqual(issueReporterModel.fileOnExtension(), true); }); }); });


this._register(AccessibleViewAction.addImplementation(95, 'inline-completions', accessor => { const accessibleViewService = accessor.get(IAccessibleViewService); const codeEditorService = accessor.get(ICodeEditorService); <ins> const contextViewService = accessor.get(IContextViewService); </ins> const show = () => { const editor = codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor(); if (!editor) {


export interface FileSearchQuery { /** * The search pattern to match against file paths. <ins> * To be correctly interpreted by Quick Open, this is interpreted in a relaxed way. The picker will apply its own highlighting and scoring on the results. * * Tips for matching in Quick Open: * With the pattern, the picker will use the file name and file paths to score each entry. The score will determine the ordering and filtering. * The scoring prioritizes prefix and substring matching. Then, it checks and it checks whether the pattern's letters appear in the same order as in the target (file name and path). * If a file does not match at all using our criteria, it will be omitted from Quick Open. </ins> */ pattern: string; }


</dict> </dict> <key>end</key> <del> <string>(?<=S)(1)((?!1)|(?=11))</string> </del> <ins> <string>(?<=S)(1)((?!1)|(?=11))b</string> </ins> <key>name</key> <string>markup.italic.markdown</string> <key>patterns</key>


} }, { <del> "name": "Markup Setext Header", "scope": "markup.heading.setext", </del> <ins> "name": "Markup Headings", "scope": [ "markup.heading", "markup.heading.setext" ], </ins> "settings": { <del> "fontStyle": "", "foreground": "#ddbb88" </del> <ins> "fontStyle": "bold", "foreground": "#6688cc" </ins> } } ],


const participant = chat.createChatParticipant('api-test.participant', (request, context, _progress, _token) => { emitter.fire({ request, context }); <del> return null; </del> }); participant.isDefault = true; disposables.push(participant);


return new Uri('file', authority, path, _empty, _empty); } <del> static from(components: { scheme: string; authority?: string; path?: string; query?: string; fragment?: string }): URI { </del> <ins> /** * Creates new URI from uri components. * * Unless `strict` is `true` the scheme is defaults to be `file`. This function performs * validation and should be used for untrusted uri components retrieved from storage, * user input, command arguments etc */ static from(components: { scheme: string; authority?: string; path?: string; query?: string; fragment?: string }, strict?: boolean): URI { </ins> const result = new Uri( components.scheme, components.authority, components.path, components.query, components.fragment, <ins> strict </ins> ); <del> _validateUri(result, true); </del> return result; }


let foldersToRestore: URI[] = []; let workspacesToRestore: IWorkspacePathToOpen[] = []; if (openConfig.initialStartup && !openConfig.cli.extensionDevelopmentPath && !openConfig.cli['disable-restore-windows']) { <del> let foldersToRestore = this.backupMainService.getFolderBackupPaths(); foldersToOpen.push(...foldersToRestore.map(f => ({ folderUri: f, remoteAuhority: getRemoteAuthority(f) }))); </del> <ins> // don't restore backuped folders, for #92318. // let foldersToRestore = this.backupMainService.getFolderBackupPaths(); // foldersToOpen.push(...foldersToRestore.map(f => ({ folderUri: f, remoteAuhority: getRemoteAuthority(f) }))); </ins> // collect from workspaces with hot-exit backups and from previous window session workspacesToRestore = [...this.backupMainService.getWorkspaceBackups(), ...this.workspacesMainService.getUntitledWorkspacesSync()];


import * as perf from 'vs/base/common/performance'; import { WorkbenchActionExecutedEvent, WorkbenchActionExecutedClassification } from 'vs/base/common/actions'; import { memoize } from 'vs/base/common/decorators'; <del> import { IFilesConfiguration, ExplorerFolderContext, FilesExplorerFocusedContext, ExplorerFocusedContext, ExplorerRootContext, ExplorerResourceReadonlyContext, ExplorerResourceCut, ExplorerResourceMoveableToTrash, ExplorerCompressedFocusContext, ExplorerCompressedFirstFocusContext, ExplorerCompressedLastFocusContext, ExplorerResourceAvailableEditorIdsContext, VIEW_ID, VIEWLET_ID, ExplorerResourceNotReadonlyContext, ViewHasSomeCollapsibleRootItemContext } from 'vs/workbench/contrib/files/common/files'; </del> <ins> import { IFilesConfiguration, ExplorerFolderContext, FilesExplorerFocusedContext, ExplorerFocusedContext, ExplorerRootContext, ExplorerResourceReadonlyContext, ExplorerResourceCut, ExplorerResourceMoveableToTrash, ExplorerCompressedFocusContext, ExplorerCompressedFirstFocusContext, ExplorerCompressedLastFocusContext, ExplorerResourceAvailableEditorIdsContext, VIEW_ID, VIEWLET_ID, ExplorerResourceNotReadonlyContext, ViewHasSomeCollapsibleRootItemContext, ExplorerViewletVisibleContext } from 'vs/workbench/contrib/files/common/files'; </ins> import { FileCopiedContext, NEW_FILE_COMMAND_ID, NEW_FOLDER_COMMAND_ID } from 'vs/workbench/contrib/files/browser/fileActions'; import * as DOM from 'vs/base/browser/dom'; import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService';


private readonly recommendationsByPattern = new Map<string, IStringDictionary<IFileOpenCondition[]>>(); private readonly fileBasedRecommendations = new Map<string, { recommendedTime: number }>(); private readonly fileBasedImportantRecommendations = new Set<string>(); <del> private readonly processedFileExtensions: string[] = []; </del> get recommendations(): ReadonlyArray<ExtensionRecommendation> { const recommendations: ExtensionRecommendation[] = [];


import { NotebookTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookTextModel'; import { INotebookService } from 'vs/workbench/contrib/notebook/common/notebookService'; import { URI } from 'vs/base/common/uri'; <del> import { IWorkingCopyService, IWorkingCopy, IWorkingCopyBackup } from 'vs/workbench/services/workingCopy/common/workingCopyService'; </del> <ins> import { IWorkingCopyService, IWorkingCopy, IWorkingCopyBackup, WorkingCopyCapabilities } from 'vs/workbench/services/workingCopy/common/workingCopyService'; </ins> import { basename } from 'vs/base/common/resources'; import { CancellationTokenSource } from 'vs/base/common/cancellation'; import { IBackupFileService } from 'vs/workbench/services/backup/common/backup';


}, { type: 'array', <del> items: { type: 'string' }, </del> <ins> prefixItems: [ { type: 'string', enum: ['absolute', 'relative', 'autoDetect', 'search'] }, ], minItems: 1, maxItems: 1, additionalItems: false }, { type: 'array', prefixItems: [ { type: 'string', enum: ['relative', 'autoDetect'] }, { type: 'string' }, ], minItems: 2, maxItems: 2, additionalItems: false, </ins> examples: [ ['relative', '${workspaceFolder}'], ['autoDetect', '${workspaceFolder}'],


} } try { <del> // Variable substitution can require user interaction, so only one of these should be running at a time. return this.variableSubstitutionQueue.queue(() => dbg.substituteVariables(folder, config)); </del> <ins> return await dbg.substituteVariables(folder, config); </ins> } catch (err) { this.showError(err.message, undefined, !!launch?.getConfiguration(config.name)); return undefined;	// bail out


// cached state if (this._fsPath) { res.fsPath = this._fsPath; <ins> res._sep = _pathSepMarker; </ins> } if (this._formatted) { res.external = this._formatted;


{ "command": "git.undoCommit", "title": "%command.undoCommit%", <del> "category": "Git" </del> <ins> "category": "Git", "enablement": "!commitInProgress" </ins> }, { "command": "git.checkout",


this.createHeader(this._commentDetailsContainer); this._body = document.createElement(`div`); this._body.classList.add('comment-body', MOUSE_CURSOR_TEXT_CSS_CLASS_NAME); <ins> if (configurationService.getValue<ICommentsConfiguration | undefined>(COMMENTS_SECTION)?.maxHeight !== false) { this._body.classList.add('comment-body-max-height'); } </ins> this.createScroll(this._commentDetailsContainer, this._body); this.updateCommentBody(this.comment.body);


import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; import { TerminalCapability } from 'vs/platform/terminal/common/capabilities/capabilities'; import { TerminalCapabilityStore } from 'vs/platform/terminal/common/capabilities/terminalCapabilityStore'; <ins> import { formatMessageForTerminal } from 'vs/platform/terminal/common/terminalStrings'; </ins> import { IColorTheme, IThemeService } from 'vs/platform/theme/common/themeService'; import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace'; import { IViewPaneOptions, ViewPane } from 'vs/workbench/browser/parts/views/viewPane';


@IUriIdentityService private readonly _uriIdentityService: IUriIdentityService ) { super(); <ins> if (!this._testing) { setInterval(function () { map.clear(); }, 10000); } </ins> } protected async _provideLinks(y: number): Promise<TerminalLink[]> {


menu: [ { id: MenuId.EditorTitle, <del> when: ctxIsMergeEditor, </del> <ins> when: ContextKeyExpr.and(ctxIsMergeEditor, ctxMergeEditorLayout.isEqualTo('columns')), </ins> group: '2_merge', order: 9, }, <del> ], precondition: ctxIsMergeEditor, </del> <ins> ] </ins> }); }


import { Emitter } from 'vs/base/common/event'; import { IMarkdownString, MarkdownStringTrustedOptions } from 'vs/base/common/htmlContent'; import { DisposableStore, IDisposable } from 'vs/base/common/lifecycle'; <ins> import 'vs/css!./renderedMarkdown'; </ins> import { applyFontInfo } from 'vs/editor/browser/config/domFontInfo'; import { ICodeEditor } from 'vs/editor/browser/editorBrowser'; import { EditorOption } from 'vs/editor/common/config/editorOptions';


dependencies: is-number "^7.0.0" <del> typescript@5.1.3: version "5.1.3" resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.1.3.tgz#8d84219244a6b40b6fb2b33cc1c062f715b9e826" integrity sha512-XH627E9vkeqhlZFQuL+UsyAXEnibT0kWR2FWONlr4sTjvxyJYnyefgrkyECLzM5NenmKzRAy2rR/OlYLA1HkZw== </del> <ins> typescript@5.1.6: version "5.1.6" resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.1.6.tgz#02f8ac202b6dad2c0dd5e0913745b47a37998274" integrity sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA== </ins> vscode-grammar-updater@^1.1.0: version "1.1.0"


} function registerOpenEditorAtIndexCommands(): void { <ins> const openEditorAtIndex: ICommandHandler = (accessor: ServicesAccessor, editorIndex: number): void => { const editorService = accessor.get(IEditorService); const activeControl = editorService.activeControl; if (activeControl) { const editor = activeControl.group.getEditor(editorIndex); if (editor) { editorService.openEditor(editor); } } }; // This command takes in the editor index number to open as an argument CommandsRegistry.registerCommand({ id: OPEN_EDITOR_AT_INDEX_COMMAND_ID, handler: openEditorAtIndex }); </ins> // Keybindings to focus a specific index in the tab folder if tabs are enabled for (let i = 0; i < 9; i++) {


height: 100%; } <ins> .monaco-workbench .activitybar > .content :not(.monaco-menu) > .monaco-action-bar .active-item-indicator { pointer-events: none; } </ins> .monaco-workbench.border .activitybar.right > .content :not(.monaco-menu) > .monaco-action-bar .active-item-indicator { left: -2px; }


let text = link.text.replace(/^file:///?/, ''); text = osPathModule(this._os).normalize(text).replace(/^(.+[/])+/, ''); <del> // Remove `:in` from the end which is how Ruby outputs stack traces text = text.replace(/:in$/, ''); </del> <ins> // Remove `:<one or more non number characters>` from the end of the link. // Examples: // - Ruby stack traces: <link>:in ... // - Grep output: <link>:<result line> text = text.replace(/:[^d]+$/, ''); </ins> // If any of the names of the folders in the workspace matches // a prefix of the link, remove that prefix and continue this._workspaceContextService.getWorkspace().folders.forEach((folder) => {


if (response === 2) { shell.openExternal('https://aka.ms/vscode-windows-unc'); <ins> return this.onUNCHostNotAllowed(path, options); // keep showing the dialog until decision (https://github.com/microsoft/vscode/issues/181956) </ins> } return undefined;


} satisfies vscode.ChatParticipant; } <del> invoke(request: vscode.ChatRequest, context: vscode.ChatContext, response: vscode.ChatExtendedResponseStream, token: CancellationToken): vscode.ProviderResult<vscode.ChatResult> { </del> <ins> invoke(request: vscode.ChatRequest, context: vscode.ChatContext, response: vscode.ChatExtendedResponseStream, token: CancellationToken): vscode.ProviderResult<vscode.ChatResult | void> { </ins> return this._requestHandler(request, context, response, token); } }


matchOnDescription: true }); if (result && result.description) { <del> this.shellLaunchConfig.icon = iconRegistry.get(result.description); </del> <ins> this._icon = iconRegistry.get(result.description); </ins> this._onIconChanged.fire(this); } }


import { CellOutputContainer } from 'vs/workbench/contrib/notebook/browser/view/cellParts/cellOutput'; import { CollapsedCodeCellExecutionIcon } from 'vs/workbench/contrib/notebook/browser/view/cellParts/codeCellExecutionIcon'; import { CodeCellRenderTemplate } from 'vs/workbench/contrib/notebook/browser/view/notebookRenderingCommon'; <del> import { CodeCellViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel'; </del> <ins> import { CodeCellViewModel, outputDisplayLimit } from 'vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel'; </ins> import { INotebookExecutionStateService } from 'vs/workbench/contrib/notebook/common/notebookExecutionStateService'; import { WordHighlighterContribution } from 'vs/editor/contrib/wordHighlighter/browser/wordHighlighter';


import { KeybindingsRegistry, KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry'; import { IListService } from 'vs/platform/list/browser/listService'; import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace'; <del> import { IDebugService, IEnablement, CONTEXT_BREAKPOINTS_FOCUSED, CONTEXT_WATCH_EXPRESSIONS_FOCUSED, CONTEXT_VARIABLES_FOCUSED, EDITOR_CONTRIBUTION_ID, IDebugEditorContribution, CONTEXT_IN_DEBUG_MODE, CONTEXT_EXPRESSION_SELECTED, CONTEXT_BREAKPOINT_SELECTED } from 'vs/workbench/parts/debug/common/debug'; </del> <ins> import { IDebugService, IEnablement, CONTEXT_BREAKPOINTS_FOCUSED, CONTEXT_WATCH_EXPRESSIONS_FOCUSED, CONTEXT_VARIABLES_FOCUSED, EDITOR_CONTRIBUTION_ID, IDebugEditorContribution, CONTEXT_IN_DEBUG_MODE, CONTEXT_EXPRESSION_SELECTED, CONTEXT_BREAKPOINT_SELECTED, IConfig } from 'vs/workbench/parts/debug/common/debug'; </ins> import { Expression, Variable, Breakpoint, FunctionBreakpoint } from 'vs/workbench/parts/debug/common/debugModel'; import { IExtensionsViewlet, VIEWLET_ID as EXTENSIONS_VIEWLET_ID } from 'vs/workbench/parts/extensions/common/extensions'; import { IViewletService } from 'vs/workbench/services/viewlet/browser/viewlet';


import { firstOrDefault } from 'vs/base/common/arrays'; import { ILanguageIdCodec, TokenizationRegistry } from 'vs/editor/common/languages'; import { PLAINTEXT_LANGUAGE_ID } from 'vs/editor/common/languages/modesRegistry'; <del> import { IObservable, observableFromEvent } from 'vs/base/common/observable'; </del> export class LanguageService extends Disposable implements ILanguageService { public _serviceBrand: undefined;


'{Locked="vscode.l10n API"}' ] }, 'The relative path to a folder containing localization (bundle.l10n.*.json) files. Must be specified if you are using the vscode.l10n API.') <ins> }, pricing: { type: 'string', markdownDescription: nls.localize('vscode.extension.pricing', 'The pricing information for the extension. Can be Free (default) or Trial. For more details visit: https://code.visualstudio.com/api/working-with-extensions/publishing-extension#extension-pricing-label'), enum: ['Free', 'Trial'], default: 'Free' </ins> } } };


} }, { <ins> "name": "Markup: Strong", "scope": "markup.bold", "settings": { "fontStyle": "bold" } }, { "name": "Markup: Emphasis", "scope": "markup.italic", "settings": { "fontStyle": "italic" } }, { </ins> "name": "Markup Inline", "scope": "markup.inline.raw", "settings": {


canMoveView: false, treeView, collapsed: false, <ins> when: ContextKeyExpr.and(EDIT_SESSIONS_SIGNED_IN, EDIT_SESSIONS_SHOW_VIEW), </ins> order: 100, hideByDefault: true, }], container);


this.storageService.store(promptedRecommendationsStorageKey, JSON.stringify(promptedRecommendations), StorageScope.PROFILE, StorageTarget.USER); } <del> private getPromptedFileExtensions(): string[] { return JSON.parse(this.storageService.get(promptedFileExtensionsStorageKey, StorageScope.PROFILE, '[]')); } private addToPromptedFileExtensions(fileExtension: string) { const promptedFileExtensions = this.getPromptedFileExtensions(); promptedFileExtensions.push(fileExtension); this.storageService.store(promptedFileExtensionsStorageKey, JSON.stringify(distinct(promptedFileExtensions)), StorageScope.PROFILE, StorageTarget.USER); } private async promptRecommendedExtensionForFileExtension(uri: URI, fileExtension: string): Promise<void> { if (this.extensionRecommendationNotificationService.hasToIgnoreRecommendationNotifications()) { return; } // Do not prompt when there is no local and remote extension management servers if (!this.extensionManagementServerService.localExtensionManagementServer && !this.extensionManagementServerService.remoteExtensionManagementServer) { return; } fileExtension = fileExtension.substring(1); // Strip the dot if (!fileExtension) { return; } const mimeTypes = getMimeTypes(uri); if (mimeTypes.length !== 1 || mimeTypes[0] !== Mimes.unknown) { return; } const fileExtensionSuggestionIgnoreList = <string[]>JSON.parse(this.storageService.get('extensionsAssistant/fileExtensionsSuggestionIgnore', StorageScope.PROFILE, '[]')); if (fileExtensionSuggestionIgnoreList.indexOf(fileExtension) > -1) { return; } const promptedFileExtensions = this.getPromptedFileExtensions(); if (promptedFileExtensions.includes(fileExtension)) { return; } const text = `ext:${fileExtension}`; const pager = await this.extensionsWorkbenchService.queryGallery({ text, pageSize: 100 }, CancellationToken.None).then(r => r, () => null); if (!pager?.firstPage.length) { return; } const installedExtensionsIds = this.extensionsWorkbenchService.local.reduce((result, i) => { result.add(i.identifier.id.toLowerCase()); return result; }, new Set<string>()); if (pager.firstPage.some(e => installedExtensionsIds.has(e.identifier.id.toLowerCase()))) { return; } this.notificationService.prompt( Severity.Info, localize('showLanguageExtensions', "The Marketplace has extensions that can help with '.{0}' files", fileExtension), [{ label: searchMarketplace, run: () => { this.addToPromptedFileExtensions(fileExtension); this.telemetryService.publicLog2<{ userReaction: string; fileExtension: string }, FileExtensionSuggestionClassification>('fileExtensionSuggestion:popup', { userReaction: 'ok', fileExtension }); this.paneCompositeService.openPaneComposite(EXTENSIONS_VIEWLET_ID, ViewContainerLocation.Sidebar, true) .then(viewlet => viewlet?.getViewPaneContainer() as IExtensionsViewPaneContainer) .then(viewlet => { viewlet.search(`ext:${fileExtension}`); viewlet.focus(); }); } }, { label: localize('dontShowAgainExtension', "Don't Show Again for '.{0}' files", fileExtension), run: () => { fileExtensionSuggestionIgnoreList.push(fileExtension); this.storageService.store( 'extensionsAssistant/fileExtensionsSuggestionIgnore', JSON.stringify(fileExtensionSuggestionIgnoreList), StorageScope.PROFILE, StorageTarget.USER); this.telemetryService.publicLog2<{ userReaction: string; fileExtension: string }, FileExtensionSuggestionClassification>('fileExtensionSuggestion:popup', { userReaction: 'neverShowAgain', fileExtension }); } }], { sticky: true, onCancel: () => { this.telemetryService.publicLog2<{ userReaction: string; fileExtension: string }, FileExtensionSuggestionClassification>('fileExtensionSuggestion:popup', { userReaction: 'cancelled', fileExtension }); } } ); } </del> private filterIgnoredOrNotAllowed(recommendationsToSuggest: string[]): string[] { const ignoredRecommendations = [...this.extensionIgnoredRecommendationsService.ignoredRecommendations, ...this.extensionRecommendationNotificationService.ignoredRecommendations]; return recommendationsToSuggest.filter(id => !ignoredRecommendations.includes(id));


export interface MarkdownContentProviderOutput { html: string; <del> containingImages: { src: string }[]; </del> <ins> containingImages: Set<string>; </ins> }


} } <del> await this.addEntriesFromStorage(workspaces, files); </del> <ins> const mergedEntries = await this.mergeEntriesFromStorage({ workspaces, files }); workspaces = mergedEntries.workspaces; files = mergedEntries.files; </ins> if (workspaces.length > WorkspacesHistoryMainService.MAX_TOTAL_RECENT_ENTRIES) { workspaces.length = WorkspacesHistoryMainService.MAX_TOTAL_RECENT_ENTRIES;


if (!link.uri) { throw new Error('Tried to open a url without a resolved URI'); } <del> this._openerService.open(link.uri || URI.parse(link.text), { </del> <ins> // It's important to use the raw string value here to avoid converting pre-encoded values // from the URL like `%2B` -> `+`. this._openerService.open(link.text, { </ins> allowTunneling: this._isRemote, allowContributedOpeners: true, });


.keybindings-editor > .keybindings-header .open-keybindings-container { margin-top: 10px; <del> opacity: 0.7; </del> display: flex; } <ins> .keybindings-editor > .keybindings-header .open-keybindings-container > div { opacity: 0.7; } </ins> .keybindings-editor > .keybindings-header .open-keybindings-container > .file-name { text-decoration: underline; cursor: pointer; margin-left: 4px; } <ins> .keybindings-editor > .keybindings-header .open-keybindings-container > .file-name:focus { opacity: 1; } </ins> /** List based styling **/ .keybindings-editor > .keybindings-body .keybindings-list-container {


export const revertIcon = registerIcon('notebook-revert', Codicon.discard, localize('revertIcon', 'Icon to revert in notebook editors.')); export const renderOutputIcon = registerIcon('notebook-render-output', Codicon.preview, localize('renderOutputIcon', 'Icon to render output in diff editor.')); export const mimetypeIcon = registerIcon('notebook-mimetype', Codicon.code, localize('mimetypeIcon', 'Icon for a mime type in notebook editors.')); <ins> export const previousChangeIcon = registerIcon('notebook-diff-editor-previous-change', Codicon.arrowUp, localize('previousChangeIcon', 'Icon for the previous change action in the diff editor.')); export const nextChangeIcon = registerIcon('notebook-diff-editor-next-change', Codicon.arrowDown, localize('nextChangeIcon', 'Icon for the next change action in the diff editor.')); </ins>


restricted: true, markdownDescription: localize('terminal.integrated.initialHint', "Controls if the first terminal without input will show a hint about available actions when it is focused."), type: 'boolean', <del> default: product.quality !== 'stable' </del> <ins> default: true </ins> } };


const windows = appInstantiationService.invokeFunction(accessor => this.openFirstWindow(accessor, electronIpcServer, sharedProcessClient)); // Post Open Windows Tasks <del> this.afterWindowOpen(); </del> <ins> appInstantiationService.invokeFunction(this.afterWindowOpen.bind(this)); </ins> // Tracing: Stop tracing after windows are ready if enabled if (this.environmentService.args.trace) {


.map(([, mode, object, stage, file]) => ({ mode, object, stage, file })); } <ins> const stashRegex = /([0-9a-f]{40})n(.*)nstash@{(d+)}n(WIPs)*on([^:]+):(.*)(?:x00)/gmi; </ins> function parseGitStashes(raw: string): Stash[] { const result: Stash[] = []; <del> const regex = /^stash@{(d+)}:(.+)$/; const descriptionRegex = /(WIPs)*on([^:]+):(.*)$/i; for (const stash of raw.split('n').filter(s => !!s)) { // Extract index and description const match = regex.exec(stash); if (!match) { continue; } const [, index, description] = match; </del> <ins> let match, hash, parents, index, wip, branchName, description; </ins> <del> // Extract branch name from description const descriptionMatch = descriptionRegex.exec(description); if (!descriptionMatch) { result.push({ index: parseInt(index), description: description.trim() }); continue; </del> <ins> do { match = stashRegex.exec(raw); if (match === null) { break; </ins> } <del> const [, wip, branchName, message] = descriptionMatch; </del> <ins> [, hash, parents, index, wip, branchName, description] = match; </ins> result.push({ <ins> hash, parents: parents.split(' '), </ins> index: parseInt(index), <del> description: wip ? `WIP (${message.trim()})` : message.trim(), branchName: branchName.trim() </del> <ins> branchName: branchName.trim(), description: wip ? `WIP (${description.trim()})` : description.trim() </ins> }); <del> } </del> <ins> } while (true); </ins> return result; }


for i in "$@" do case "$i" in <del> --user-data-dir | --user-data-dir=* | --file-write ) </del> <ins> --user-data-dir | --user-data-dir=* | --file-write | tunnel | serve-web ) </ins> CAN_LAUNCH_AS_ROOT=1 ;; esac


registerDocumentSemanticTokensProvider: <any>registerDocumentSemanticTokensProvider, registerDocumentRangeSemanticTokensProvider: <any>registerDocumentRangeSemanticTokensProvider, registerInlineCompletionsProvider: <any>registerInlineCompletionsProvider, <ins> registerInlayHintsProvider: <any>registerInlayHintsProvider, </ins> // enums DocumentHighlightKind: standaloneEnums.DocumentHighlightKind,


const NavbarSection = { Readme: 'readme', <del> Contributions: 'contributions', </del> <ins> FeatureContributions: 'contributions', </ins> Changelog: 'changelog', Dependencies: 'dependencies', ExtensionPack: 'extensionPack'


import { INotificationService } from 'vs/platform/notification/common/notification'; import { Dimension } from 'vs/base/browser/dom'; import { localize } from 'vs/nls'; <del> import { IDisposable } from 'vs/base/common/lifecycle'; </del> <ins> import { dispose, IDisposable } from 'vs/base/common/lifecycle'; import { RawContextKey, IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; const ActivePanleContextId = 'activePanel'; export const ActivePanelContext = new RawContextKey<string>(ActivePanleContextId, ''); </ins> export class PanelPart extends CompositePart<Panel> implements IPanelService {


if (this.editor.hasTextFocus()) { if (this.editor.getModel()?.uri.scheme !== Schemas.vscodeNotebookCell && WordHighlighter.query?.modelInfo?.model.uri.scheme !== Schemas.vscodeNotebookCell) { // clear query if focused non-nb editor WordHighlighter.query = null; <del> this._run(); </del> <ins> this._run(); // TODO: @Yoyokrazy -- investigate why we need a full rerun here. likely addressed a case/patch in the first iteration of this feature </ins> } else { // remove modelInfo to account for nb cell being disposed if (WordHighlighter.query?.modelInfo) { WordHighlighter.query.modelInfo = null;


@IModelService _modelService: IModelService, @IConfigurationService _configurationService: IConfigurationService, @IContextKeyService _contextKeyService: IContextKeyService, <del> @ITerminalService _terminalService: ITerminalService, @IConfigurationService configurationService: IConfigurationService </del> <ins> @ITerminalService _terminalService: ITerminalService </ins> ) { super(); }


error.message = data.message; error.stack = data.stack; this._internalExtensionService._onExtensionRuntimeError(extensionId, error); <del> console.error(`[${extensionId}]${error.message}`); </del> <ins> console.error(`[${extensionId.value}]${error.message}`); </ins> console.error(error.stack); } async $onExtensionActivationError(extensionId: ExtensionIdentifier, data: SerializedError, missingExtensionDependency: MissingExtensionDependency | null): Promise<void> {


import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles'; import { IFileDialogService } from 'vs/platform/dialogs/common/dialogs'; import { joinPath } from 'vs/base/common/resources'; <ins> import { Codicon } from 'vs/base/common/codicons'; </ins> export class UserDataProfilesWorkbenchContribution extends Disposable implements IWorkbenchContribution {


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


}); } } <ins> const before = this._tree.getFocus().length; </ins> this._tree.setChildren(null, elements); <ins> // Temporary fix until we figure out why the tree doesn't fire an event when focus & selection // get changed to empty arrays. if (before > 0 && elements.length === 0) { this._onTriggerEmptySelectionOrFocus.fire({ elements: [] }); } </ins> this._tree.layout(); this._onChangedAllVisibleChecked.fire(this.getAllVisibleChecked());


import 'vs/workbench/browser/parts/sidebar/sidebarActions'; import { ActivityBarPosition, IWorkbenchLayoutService, LayoutSettings, Parts, Position as SideBarPosition } from 'vs/workbench/services/layout/browser/layoutService'; import { SidebarFocusContext, ActiveViewletContext } from 'vs/workbench/common/contextkeys'; <del> import { IStorageService } from 'vs/platform/storage/common/storage'; </del> <ins> import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage'; </ins> import { IContextMenuService } from 'vs/platform/contextview/browser/contextView'; import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';


const verbose = this._configurationService.getValue(provider.verbositySettingKey); const hasActions = this._accessibleViewSupportsNavigation.get() || this._accessibleViewVerbosityEnabled.get() || this._accessibleViewGoToSymbolSupported.get() || this._currentProvider?.actions; if (verbose && !showAccessibleViewHelp && hasActions) { <del> actionsHint = localize('ariaAccessibleViewActions', 'Explore actions such as disabling this hint (Shift+Tab).'); </del> <ins> actionsHint = provider.options.positionBottom ? localize('ariaAccessibleViewActionsBottom', 'Explore actions such as disabling this hint (Shift+Tab), use Escape to exit this dialog.') : localize('ariaAccessibleViewActions', 'Explore actions such as disabling this hint (Shift+Tab).'); </ins> } let ariaLabel = provider.options.type === AccessibleViewType.Help ? localize('accessibility-help', "Accessibility Help") : localize('accessible-view', "Accessible View"); this._title.textContent = ariaLabel;


} terminalToReuse.terminal.scrollToBottom(); <del> launchConfigs.reconnectionProperties = { ownerId: ReconnectionType, data: { lastTask: task.getCommonTaskId(), group, label: task._label, id: task._id } }; </del> <ins> if (task.configurationProperties.isBackground) { launchConfigs.reconnectionProperties = { ownerId: ReconnectionType, data: { lastTask: task.getCommonTaskId(), group, label: task._label, id: task._id } }; } </ins> await terminalToReuse.terminal.reuseTerminal(launchConfigs); if (task.command.presentation && task.command.presentation.clear) {


import { isObject, isString, isUndefined, isNumber, withNullAsUndefined } from 'vs/base/common/types'; import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation'; import { KeybindingsRegistry, KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry'; <del> import { TextCompareEditorVisibleContext, IEditorIdentifier, IEditorCommandsContext, ActiveEditorGroupEmptyContext, MultipleEditorGroupsContext, CloseDirection, IVisibleEditorPane, ActiveEditorStickyContext, EditorsOrder, EditorInputCapabilities, isEditorIdentifier, ActiveEditorGroupLockedContext, ActiveEditorCanSplitInGroupContext, GroupIdentifier, TextCompareEditorActiveContext, SideBySideEditorActiveContext, isEditorInputWithOptionsAndGroup } from 'vs/workbench/common/editor'; </del> <ins> import { TextCompareEditorVisibleContext, IEditorIdentifier, IEditorCommandsContext, ActiveEditorGroupEmptyContext, MultipleEditorGroupsContext, CloseDirection, IVisibleEditorPane, ActiveEditorStickyContext, EditorsOrder, EditorInputCapabilities, isEditorIdentifier, ActiveEditorGroupLockedContext, ActiveEditorCanSplitInGroupContext, GroupIdentifier, TextCompareEditorActiveContext, SideBySideEditorActiveContext, isEditorInputWithOptionsAndGroup, IUntitledTextResourceEditorInput } from 'vs/workbench/common/editor'; </ins> import { EditorInput } from 'vs/workbench/common/editor/editorInput'; import { EditorGroupColumn, columnToEditorGroup } from 'vs/workbench/services/editor/common/editorGroupColumn'; import { ACTIVE_GROUP_TYPE, IEditorService, SIDE_GROUP, SIDE_GROUP_TYPE } from 'vs/workbench/services/editor/common/editorService';


assert.strictEqual((<FormatString>variable.transform!.children[0]).ifValue, ''); assert.strictEqual((<FormatString>variable.transform!.children[0]).elseValue, undefined); }); <ins> test('Snippet placeholder empty right after expansion #152553', function () { const snippet = new SnippetParser().parse('${1:prog}: ${2:$1.cc} - $2'); const actual = snippet.toString(); assert.strictEqual(actual, 'prog: prog.cc - prog.cc'); const snippet2 = new SnippetParser().parse('${1:prog}: ${3:${2:$1.cc}.33} - $2 $3'); const actual2 = snippet2.toString(); assert.strictEqual(actual2, 'prog: prog.cc.33 - prog.cc prog.cc.33'); // cyclic references of placeholders const snippet3 = new SnippetParser().parse('${1:$2.one} <> ${2:$1.two}'); const actual3 = snippet3.toString(); assert.strictEqual(actual3, '.two.one.two.one <> .one.two.one.two'); }); </ins> });


import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions, IWorkbenchContribution } from 'vs/workbench/common/contributions'; import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors'; import { VIEWLET_ID, IExtensionsWorkbenchService, IExtensionsViewPaneContainer, TOGGLE_IGNORE_EXTENSION_ACTION_ID, INSTALL_EXTENSION_FROM_VSIX_COMMAND_ID, WORKSPACE_RECOMMENDATIONS_VIEW_ID, IWorkspaceRecommendedExtensionsView, AutoUpdateConfigurationKey, HasOutdatedExtensionsContext, SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID, LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID, ExtensionEditorTab, THEME_ACTIONS_GROUP, INSTALL_ACTIONS_GROUP, OUTDATED_EXTENSIONS_VIEW_ID, CONTEXT_HAS_GALLERY, IExtension, extensionsSearchActionsMenu } from 'vs/workbench/contrib/extensions/common/extensions'; <del> import { ReinstallAction, InstallSpecificVersionOfExtensionAction, ConfigureWorkspaceRecommendedExtensionsAction, ConfigureWorkspaceFolderRecommendedExtensionsAction, PromptExtensionInstallFailureAction, SearchExtensionsAction, SwitchToPreReleaseVersionAction, SwitchToReleasedVersionAction, SetColorThemeAction, SetFileIconThemeAction, SetProductIconThemeAction, ClearLanguageAction } from 'vs/workbench/contrib/extensions/browser/extensionsActions'; </del> <ins> import { ReinstallAction, InstallSpecificVersionOfExtensionAction, ConfigureWorkspaceRecommendedExtensionsAction, ConfigureWorkspaceFolderRecommendedExtensionsAction, PromptExtensionInstallFailureAction, SearchExtensionsAction, SwitchToPreReleaseVersionAction, SwitchToReleasedVersionAction, SetColorThemeAction, SetFileIconThemeAction, SetProductIconThemeAction, ClearLanguageAction, SkipUpdateAction } from 'vs/workbench/contrib/extensions/browser/extensionsActions'; </ins> import { ExtensionsInput } from 'vs/workbench/contrib/extensions/common/extensionsInput'; import { ExtensionEditor } from 'vs/workbench/contrib/extensions/browser/extensionEditor'; import { StatusUpdater, MaliciousExtensionChecker, ExtensionsViewletViewsContribution, ExtensionsViewPaneContainer, BuiltInExtensionsContext, SearchMarketplaceExtensionsContext, RecommendedExtensionsContext, DefaultViewsContext, ExtensionsSortByContext, SearchHasTextContext } from 'vs/workbench/contrib/extensions/browser/extensionsViewlet';


import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace'; import { IStorageService } from 'vs/platform/storage/common/storage'; import { ITextResourceConfigurationService } from 'vs/editor/common/services/resourceConfiguration'; <del> import { IHistoryService } from 'vs/workbench/services/history/common/history'; </del> import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; import { CancelAction } from 'vs/platform/message/common/message'; import { IWorkbenchEditorService } from 'vs/workbench/services/editor/common/editorService';


test('updateState', () => { changed.clear(); <del> r.updateState(new TestId(['ctrlId', 'id-a', 'id-aa']).toString(), 't', TestResultState.Running); </del> <ins> const testId = new TestId(['ctrlId', 'id-a', 'id-aa']).toString(); r.updateState(testId, 't', TestResultState.Running); </ins> assert.deepStrictEqual(r.counts, { ...makeEmptyCounts(), [TestResultState.Unset]: 2, [TestResultState.Running]: 1, [TestResultState.Queued]: 1, }); <del> assert.deepStrictEqual(r.getStateById(new TestId(['ctrlId', 'id-a', 'id-aa']).toString())?.ownComputedState, TestResultState.Running); </del> <ins> assert.deepStrictEqual(r.getStateById(testId)?.ownComputedState, TestResultState.Running); </ins> // update computed state: assert.deepStrictEqual(r.getStateById(tests.root.id)?.computedState, TestResultState.Running); assert.deepStrictEqual(getChangeSummary(), [


fullScreenZenMode: boolean; zoomLevel: number; titleBarStyle: 'native' | 'custom'; <ins> autoDetectHighContrast: boolean; </ins> }


} } <ins> // FolderMatch on a leaf node does not always run the for-loop of folderMatch because it does not have a FolderMatch as a child. // Therefore, FileMatch is also searched to check for the existence of AIResults const fileIterator = this.fileMatchesIterator(); for (const elem of fileIterator) { if (elem.hasDownstreamNonAIResults()) { return true; } } </ins> return false; }


extensionWorkbenchService.open(extension, { showPreReleaseVersion: true }); } }); this.registerExtensionAction({ id: 'workbench.extensions.action.showReleasedVersion', title: { value: localize('show released version', "Show Release Version"), original: 'Show Release Version' },


* Defaults to false. */ peekWidgetDefaultFocus?: 'tree' | 'editor'; <ins> /** * Controls whether the definition link opens element in the peek widget. * Defaults to false. */ definitionLinkOpensInPeek?: boolean; </ins> } export interface IEditorConstructionOptions extends IEditorOptions {


} const model = controller.getOrCreateModel(); <del> const atEdge = model.move(this._isNext, false); if (!atEdge) { </del> <ins> const atEdge = model.move(this._isNext, !this._multiFile); if (!atEdge || !this._multiFile) { </ins> return undefined; }


id: 'workbench.action.chat.focusInput', title: localize2('interactiveSession.focusInput.label', "Focus Chat Input"), f1: false, <del> keybinding: { primary: KeyMod.CtrlCmd | KeyCode.DownArrow, weight: KeybindingWeight.WorkbenchContrib, when: ContextKeyExpr.and(CONTEXT_IN_CHAT_SESSION, CONTEXT_IN_CHAT_INPUT.negate()) } </del> <ins> keybinding: [ { primary: KeyMod.CtrlCmd | KeyCode.DownArrow, weight: KeybindingWeight.WorkbenchContrib, when: ContextKeyExpr.and(CONTEXT_IN_CHAT_SESSION, CONTEXT_IN_CHAT_INPUT.negate(), CONTEXT_IN_QUICK_CHAT.negate()), }, { when: ContextKeyExpr.and(CONTEXT_IN_CHAT_SESSION, CONTEXT_IN_CHAT_INPUT.negate(), CONTEXT_IN_QUICK_CHAT), primary: KeyMod.CtrlCmd | KeyCode.UpArrow, weight: KeybindingWeight.WorkbenchContrib, } ] </ins> }); } run(accessor: ServicesAccessor, ...args: any[]) {


dispose(): void; } <ins> function clearContainer(container: HTMLElement) { while (container.firstChild) { container.removeChild(container.firstChild); } } </ins> function renderImage(outputInfo: OutputItem, element: HTMLElement): IDisposable {


config.port = parseInt(matches[2]); } <del> ipcRenderer.send('vscode:workbenchCommand', { id: 'workbench.action.debug.start', from: 'processExplorer', args: [config] }); </del> <ins> ipcRenderer.send('vscode:workbenchCommand', { id: 'debug.startFromConfig', from: 'processExplorer', args: [config] }); </ins> } function getProcessIdWithHighestProperty(processList, propertyName: string) {


const newDecorations: IModelDeltaDecoration[] = []; for (const command of commands) { <del> const withSlash = `/${command.command}`; </del> <ins> const withSlash = `/${command.command} `; </ins> const firstLine = this._inputModel.getLineContent(1); if (firstLine.startsWith(withSlash)) { newDecorations.push({


return md.use(katex, { globalGroup: true, enableBareBlocks: true, <del> macros </del> <ins> enableFencedBlocks: true, macros, </ins> }); }); }


export function makeKeyOptionalMessage(markerData: IMarkerData, useMessage: boolean): string { let result: string[] = [emptyString]; if (markerData.source) { <del> result.push(markerData.source.replace('¦', '¦')); </del> <ins> result.push(markerData.source.replace('¦', '¦')); </ins> } else { result.push(emptyString); } if (markerData.code) { if (typeof markerData.code === 'string') { <del> result.push(markerData.code.replace('¦', '¦')); </del> <ins> result.push(markerData.code.replace('¦', '¦')); </ins> } else { <del> result.push(markerData.code.value.replace('¦', '¦')); </del> <ins> result.push(markerData.code.value.replace('¦', '¦')); </ins> } } else { result.push(emptyString);


instantiationService.stub(IKeybindingService, new MockKeybindingService()); instantiationService.stub(INotebookCellStatusBarService, disposables.add(new NotebookCellStatusBarService())); instantiationService.stub(ICodeEditorService, disposables.add(new TestCodeEditorService(testThemeService))); <del> instantiationService.stub(IInlineChatService, instantiationService.createInstance(InlineChatServiceImpl)); </del> instantiationService.stub(INotebookCellOutlineProviderFactory, instantiationService.createInstance(NotebookCellOutlineProviderFactory)); instantiationService.stub(ILanguageDetectionService, new class MockLanguageDetectionService implements ILanguageDetectionService {


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ import { deepStrictEqual } from 'assert'; import { getLinkSuffix, removeLinkSuffix } from 'vs/workbench/contrib/terminal/browser/links/terminalLinkParsing'; interface ITestLink { link: string; suffix: string | undefined; hasRow: boolean; hasCol: boolean; } const testRow = 339; const testCol = 12; const testLinks: ITestLink[] = [ { link: 'foo', suffix: undefined, hasRow: false, hasCol: false }, { link: 'foo:339', suffix: ':339', hasRow: true, hasCol: false }, { link: 'foo:339:12', suffix: ':339:12', hasRow: true, hasCol: true }, { link: 'foo 339', suffix: ' 339', hasRow: true, hasCol: false }, { link: 'foo 339:12', suffix: ' 339:12', hasRow: true, hasCol: true }, { link: '"foo",339', suffix: '",339', hasRow: true, hasCol: false }, { link: '"foo",339:12', suffix: '",339:12', hasRow: true, hasCol: true }, { link: '"foo", line 339', suffix: '", line 339', hasRow: true, hasCol: false }, { link: '"foo", line 339, col 12', suffix: '", line 339, col 12', hasRow: true, hasCol: true }, { link: '"foo", line 339, column 12', suffix: '", line 339, column 12', hasRow: true, hasCol: true }, { link: '"foo":line 339', suffix: '":line 339', hasRow: true, hasCol: false }, { link: '"foo":line 339, col 12', suffix: '":line 339, col 12', hasRow: true, hasCol: true }, { link: '"foo":line 339, column 12', suffix: '":line 339, column 12', hasRow: true, hasCol: true }, { link: '"foo": line 339', suffix: '": line 339', hasRow: true, hasCol: false }, { link: '"foo": line 339, col 12', suffix: '": line 339, col 12', hasRow: true, hasCol: true }, { link: '"foo": line 339, column 12', suffix: '": line 339, column 12', hasRow: true, hasCol: true }, { link: '"foo" on line 339', suffix: '" on line 339', hasRow: true, hasCol: false }, { link: '"foo" on line 339, col 12', suffix: '" on line 339, col 12', hasRow: true, hasCol: true }, { link: '"foo" on line 339, column 12', suffix: '" on line 339, column 12', hasRow: true, hasCol: true }, { link: 'foo(339)', suffix: '(339)', hasRow: true, hasCol: false }, { link: 'foo(339,12)', suffix: '(339,12)', hasRow: true, hasCol: true }, { link: 'foo(339, 12)', suffix: '(339, 12)', hasRow: true, hasCol: true }, { link: 'foo (339)', suffix: ' (339)', hasRow: true, hasCol: false }, { link: 'foo (339,12)', suffix: ' (339,12)', hasRow: true, hasCol: true }, { link: 'foo (339, 12)', suffix: ' (339, 12)', hasRow: true, hasCol: true }, ]; suite('TerminalLinkParsing', () => { suite('removeLinkSuffix', () => { for (const testLink of testLinks) { test('`' + testLink.link + '`', () => { deepStrictEqual( removeLinkSuffix(testLink.link), testLink.suffix === undefined ? testLink.link : testLink.link.replace(testLink.suffix, '') ); }); } }); suite('getLinkSuffix', () => { for (const testLink of testLinks) { test('`' + testLink.link + '`', () => { deepStrictEqual( getLinkSuffix(testLink.link), testLink.suffix === undefined ? null : { row: testLink.hasRow ? testRow : undefined, col: testLink.hasCol ? testCol : undefined, suffix: { index: testLink.link.length - testLink.suffix.length, text: testLink.suffix } } as ReturnType<typeof getLinkSuffix> ); }); } }); }); </ins>


"vscode-proxy-agent": "^0.12.0", "vscode-regexpp": "^3.1.0", "vscode-textmate": "9.0.0", <del> "xterm": "5.2.0-beta.30", "xterm-addon-canvas": "0.4.0-beta.7", </del> <ins> "xterm": "5.2.0-beta.33", "xterm-addon-canvas": "0.4.0-beta.9", </ins> "xterm-addon-search": "0.11.0", "xterm-addon-serialize": "0.9.0", "xterm-addon-unicode11": "0.5.0", <del> "xterm-addon-webgl": "0.15.0-beta.7", "xterm-headless": "5.2.0-beta.30", </del> <ins> "xterm-addon-webgl": "0.15.0-beta.8", "xterm-headless": "5.2.0-beta.33", </ins> "yauzl": "^2.9.2", "yazl": "^2.4.3" },


const focusTracker = this._register(dom.trackFocus(this._stickyScrollWidget.getDomNode())); this._register(focusTracker.onDidBlur(_ => { const height = this._stickyScrollWidget.getDomNode().clientHeight; <del> if (height !== 0) { this._disposeFocusStickyScrollStore(); } else { // If the height is 0, then the blur has been caused by scrolling. In that case keep the focus on the sticky scroll. </del> <ins> // Suppose that the blurring is caused by scrolling, then keep the focus on the sticky scroll // This is determined by the fact that the height of the widget has become zero and there has been no position revealing if (this._positionRevealed === false && height === 0) { </ins> this._focusedStickyElementIndex = -1; this.focus(); <ins> } // In all other casees, dispose the focus on the sticky scroll else { this._disposeFocusStickyScrollStore(); </ins> } })); this._register(focusTracker.onDidFocus(_ => { this.focus(); })); this._register(this._createClickLinkGesture()); <ins> // Suppose that mouse down on the sticky scroll, then do not focus on the sticky scroll because this will be followed by the revealing of a position this._register(dom.addDisposableListener(this._stickyScrollWidget.getDomNode(), dom.EventType.MOUSE_DOWN, (e) => { this._onMouseDown = true; })); </ins> } get stickyScrollCandidateProvider(): IStickyLineCandidateProvider {


} private _layout(): void { <del> const height = Math.max(this._editor.getLayoutInfo().height / 4, 250); </del> <ins> const height = Math.max(this._editor.getLayoutInfo().height / 4, 250, ContentHoverWidget._lastDimensions.height); const width = Math.max(this._editor.getLayoutInfo().width * 0.66, 500, ContentHoverWidget._lastDimensions.width); </ins> const { fontSize, lineHeight } = this._editor.getOption(EditorOption.fontInfo); const contentsDomNode = this._hover.contentsDomNode; contentsDomNode.style.fontSize = `${fontSize}px`; contentsDomNode.style.lineHeight = `${lineHeight / fontSize}`; <del> this._setContentsDomNodeMaxDimensions(Math.max(this._editor.getLayoutInfo().width * 0.66, 500), height); </del> <ins> this._setContentsDomNodeMaxDimensions(width, height); </ins> } private _updateFont(): void {


"type": "string", "enum": [ "npm", <del> "yarn" </del> <ins> "yarn", "pnpm" </ins> ], "default": "npm", "description": "%config.npm.packageManager%"


*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; </del> import { ExtensionRecommendations, ExtensionRecommendation } from 'vs/workbench/contrib/extensions/browser/extensionRecommendations'; <del> import { INotificationService, Severity } from 'vs/platform/notification/common/notification'; import { EnablementState, IExtensionManagementServerService } from 'vs/workbench/services/extensionManagement/common/extensionManagement'; </del> <ins> import { EnablementState } from 'vs/workbench/services/extensionManagement/common/extensionManagement'; </ins> import { ExtensionRecommendationReason, IExtensionIgnoredRecommendationsService } from 'vs/workbench/services/extensionRecommendations/common/extensionRecommendations'; <del> import { IExtensionsViewPaneContainer, IExtensionsWorkbenchService, IExtension, VIEWLET_ID as EXTENSIONS_VIEWLET_ID } from 'vs/workbench/contrib/extensions/common/extensions'; import { CancellationToken } from 'vs/base/common/cancellation'; </del> <ins> import { IExtensionsWorkbenchService, IExtension } from 'vs/workbench/contrib/extensions/common/extensions'; </ins> import { localize } from 'vs/nls'; import { StorageScope, IStorageService, StorageTarget } from 'vs/platform/storage/common/storage'; import { IProductService } from 'vs/platform/product/common/productService';


import { Repl, ClearReplAction } from 'vs/workbench/parts/debug/electron-browser/repl'; import { DebugQuickOpenHandler } from 'vs/workbench/parts/debug/browser/debugQuickOpen'; import { DebugStatus } from 'vs/workbench/parts/debug/browser/debugStatus'; <del> import { LifecyclePhase, ILifecycleService } from 'vs/platform/lifecycle/common/lifecycle'; </del> <ins> import { LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle'; </ins> import { launchSchemaId } from 'vs/workbench/services/configuration/common/configuration'; import { IEditorGroupsService } from 'vs/workbench/services/group/common/editorGroupsService'; import { LoadedScriptsView } from 'vs/workbench/parts/debug/browser/loadedScriptsView'; import { TOGGLE_LOG_POINT_ID, TOGGLE_CONDITIONAL_BREAKPOINT_ID, TOGGLE_BREAKPOINT_ID } from 'vs/workbench/parts/debug/browser/debugEditorActions'; <del> import { INotificationService } from 'vs/platform/notification/common/notification'; import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; </del> class OpenDebugViewletAction extends ShowViewletAction { public static readonly ID = VIEWLET_ID;


.monaco-editor .inline-folded:after { color: grey; margin: 0.1em 0.2em 0 0.2em; <del> content: "⋯"; </del> <ins> content: "22EF"; /* ellipses unicode character */ </ins> display: inline; line-height: 1em; cursor: pointer;


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ .monaco-editor .resizable-widget { z-index: 40; display: block; } </ins>


export const errorForeground = registerColor('errorForeground', { dark: '#F48771', light: '#A1260D', hc: '#F48771' }, nls.localize('errorForeground', "Overall foreground color for error messages. This color is only used if not overridden by a component.")); export const descriptionForeground = registerColor('descriptionForeground', { light: '#717171', dark: transparent(foreground, 0.7), hc: transparent(foreground, 0.7) }, nls.localize('descriptionForeground', "Foreground color for description text providing additional information, for example for a label.")); <del> export const focusBorder = registerColor('focusBorder', { dark: Color.fromHex('#0E639C').transparent(0.6), light: Color.fromHex('#007ACC').transparent(0.4), hc: '#F38518' }, nls.localize('focusBorder', "Overall border color for focused elements. This color is only used if not overridden by a component.")); </del> <ins> export const focusBorder = registerColor('focusBorder', { dark: Color.fromHex('#0E639C').transparent(0.8), light: Color.fromHex('#007ACC').transparent(0.4), hc: '#F38518' }, nls.localize('focusBorder', "Overall border color for focused elements. This color is only used if not overridden by a component.")); </ins> export const contrastBorder = registerColor('contrastBorder', { light: null, dark: null, hc: '#6FC3DF' }, nls.localize('contrastBorder', "An extra border around elements to separate them from others for greater contrast.")); export const activeContrastBorder = registerColor('contrastActiveBorder', { light: null, dark: null, hc: focusBorder }, nls.localize('activeContrastBorder', "An extra border around active elements to separate them from others for greater contrast."));


import type { ILink, ILinkProvider, IViewportRange, Terminal } from 'xterm'; import { convertBufferRangeToViewport } from 'vs/workbench/contrib/terminal/browser/links/terminalLinkHelpers'; import { RunOnceScheduler } from 'vs/base/common/async'; <ins> import { removeLinkSuffix } from 'vs/workbench/contrib/terminal/browser/links/terminalLinkParsing'; </ins> export type XtermLinkMatcherHandler = (event: MouseEvent | undefined, link: string) => Promise<void>;


* If successful, places commandToRun on the command line */ freePortKillProcess(port: string, commandToRun: string): Promise<void>; <ins> /** * Update the parent context key service to use for this terminal instance. */ setParentContextKeyService(parentContextKeyService: IContextKeyService): void; </ins> } export const enum XtermTerminalConstants {


return config.get<boolean>('math.enabled', true); } <ins> function getMacros(): { [key: string]: string } { const config = vscode.workspace.getConfiguration('markdown'); return config.get<{ [key: string]: string }>('math.macros', {}); } </ins> vscode.workspace.onDidChangeConfiguration(e => { <del> if (e.affectsConfiguration(enabledSetting)) { </del> <ins> if (e.affectsConfiguration(markdownMathSetting)) { </ins> vscode.commands.executeCommand('markdown.api.reloadPlugins'); } }, undefined, context.subscriptions);


"telemetry", "windowActivity", "interactiveUserActions", <del> "envCollectionWorkspace", </del> "envCollectionOptions" ], "private": true,


return; } <ins> if (e.browserEvent.defaultPrevented) { return; } </ins> const node = e.element; if (!node) {


export const editorBracketHighlightingForeground5 = registerColor('editorBracketHighlight.foreground5', '#00000000', nls.localize('editorBracketHighlightForeground5', 'Foreground color of brackets (5). Requires enabling bracket pair colorization.')); export const editorBracketHighlightingForeground6 = registerColor('editorBracketHighlight.foreground6', '#00000000', nls.localize('editorBracketHighlightForeground6', 'Foreground color of brackets (6). Requires enabling bracket pair colorization.')); <del> export const editorBracketHighlightingUnexpectedBracketForeground = registerColor('editorBracketHighlight.unexpectedBracket.foreground', { dark: new Color(new RGBA(255, 18, 18, 0.8)), light: new Color(new RGBA(255, 18, 18, 0.8)), hcDark: new Color(new RGBA(255, 50, 50, 1)), hcLight: '' }, nls.localize('editorBracketHighlightUnexpectedBracketForeground', 'Foreground color of unexpected brackets.')); </del> <ins> export const editorBracketHighlightingUnexpectedBracketForeground = registerColor('editorBracketHighlight.unexpectedBracket.foreground', { dark: new Color(new RGBA(255, 18, 18, 0.8)), light: new Color(new RGBA(255, 18, 18, 0.8)), hcDark: 'new Color(new RGBA(255, 50, 50, 1))', hcLight: '#B5200D' }, nls.localize('editorBracketHighlightUnexpectedBracketForeground', 'Foreground color of unexpected brackets.')); </ins> export const editorBracketPairGuideBackground1 = registerColor('editorBracketPairGuide.background1', '#00000000', nls.localize('editorBracketPairGuide.background1', 'Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides.')); export const editorBracketPairGuideBackground2 = registerColor('editorBracketPairGuide.background2', '#00000000', nls.localize('editorBracketPairGuide.background2', 'Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides.'));


await this.takeAction(action.extensionDescription, action.description); } } <ins> } else { await this.takeAction(this.values[0].extensionDescription, await this.values[0].url); </ins> } <del> await this.takeAction(this.values[0].extensionDescription, await this.values[0].url); </del> }


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


append(keyboardMarker, $('span.title', {}, `${commandAndGroupLabel} `)); } <del> if ((options.showKeys ?? true) || (commandDetails && (options.showKeybindings ?? true))) { </del> <ins> if ((options.showKeys ?? true) || ((options.showKeybindings ?? true) && this._isKbFound(shortcut))) { </ins> // Fix label for arrow keys keyLabel = keyLabel?.replace('UpArrow', '↑') ?.replace('DownArrow', '↓')


this.list.setSelection([focus], e.browserEvent); } <ins> e.browserEvent.preventDefault(); </ins> this._onPointer.fire(e); }


} } } <ins> /** * Copied from src/vs/base/common/uuid.ts */ function generateUuid() { // use `randomValues` if possible function getRandomValues(bucket: Uint8Array): Uint8Array { for (let i = 0; i < bucket.length; i++) { bucket[i] = Math.floor(Math.random() * 256); } return bucket; } // prep-work const _data = new Uint8Array(16); const _hex: string[] = []; for (let i = 0; i < 256; i++) { _hex.push(i.toString(16).padStart(2, '0')); } // get data getRandomValues(_data); // set version bits _data[6] = (_data[6] & 0x0f) | 0x40; _data[8] = (_data[8] & 0x3f) | 0x80; // print as string let i = 0; let result = ''; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += '-'; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += '-'; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += '-'; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += '-'; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; return result; } </ins>


import { defaultInputBoxStyles, defaultToggleStyles } from 'vs/platform/theme/browser/defaultStyles'; import { diffInserted, diffInsertedOutline, diffRemoved, diffRemovedOutline, editorFindMatchHighlight, editorFindMatchHighlightBorder, foreground, listActiveSelectionForeground, textLinkActiveForeground, textLinkForeground, toolbarActiveBackground, toolbarHoverBackground } from 'vs/platform/theme/common/colorRegistry'; import { isHighContrast } from 'vs/platform/theme/common/theme'; <del> import { IColorTheme, ICssStyleCollector, IThemeService, registerThemingParticipant, ThemeIcon } from 'vs/platform/theme/common/themeService'; </del> <ins> import { IColorTheme, ICssStyleCollector, IFileIconTheme, IThemeService, registerThemingParticipant, ThemeIcon } from 'vs/platform/theme/common/themeService'; </ins> import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace'; import { OpenFileFolderAction, OpenFolderAction } from 'vs/workbench/browser/actions/workspaceActions'; import { ResourceListDnDHandler } from 'vs/workbench/browser/dnd';


} } if (this.ui.list.ariaLabel !== ariaLabel) { <del> this.ui.list.ariaLabel = ariaLabel; </del> <ins> this.ui.list.ariaLabel = withUndefinedAsNull(ariaLabel); </ins> } this.ui.list.matchOnDescription = this.matchOnDescription; this.ui.list.matchOnDetail = this.matchOnDetail;


font-size: 25px; } <del> .monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-body .dialog-message .description-container { </del> <ins> #monaco-dialog-message-body > .message-body > p { display: flex; font-size: 16px; background: var(--vscode-welcomePage-tileHoverBackground); border-radius: 6px; padding: 20px; min-height: auto; word-wrap: break-word; overflow-wrap:break-word; } #monaco-dialog-message-body > .link > p { font-size: 16px; } .monaco-dialog-box > .dialog-buttons-row > .dialog-buttons > .monaco-button{ </ins> font-size: 16px; }


return recent.workspace.configPath; } <del> private indexOfWorkspace(recents: IRecent[], candidate: IWorkspaceIdentifier): number { return recents.findIndex(recent => isRecentWorkspace(recent) && recent.workspace.id === candidate.id); </del> <ins> private containsWorkspace(recents: IRecent[], candidate: IWorkspaceIdentifier): boolean { return !!recents.find(recent => isRecentWorkspace(recent) && recent.workspace.id === candidate.id); </ins> } <del> private indexOfFolder(recents: IRecent[], candidate: URI): number { return recents.findIndex(recent => isRecentFolder(recent) && extUriBiasedIgnorePathCase.isEqual(recent.folderUri, candidate)); </del> <ins> private containsFolder(recents: IRecent[], candidate: URI): boolean { return !!recents.find(recent => isRecentFolder(recent) && extUriBiasedIgnorePathCase.isEqual(recent.folderUri, candidate)); </ins> } <del> private indexOfFile(recents: IRecentFile[], candidate: URI): number { return recents.findIndex(recent => extUriBiasedIgnorePathCase.isEqual(recent.fileUri, candidate)); </del> <ins> private containsFile(recents: IRecentFile[], candidate: URI): boolean { return !!recents.find(recent => extUriBiasedIgnorePathCase.isEqual(recent.fileUri, candidate)); </ins> } //#endregion


const visibleIndex = i + 1; KeybindingsRegistry.registerCommandAndKeybindingRule({ <del> id: 'workbench.action.openEditorAtIndex' + visibleIndex, </del> <ins> id: OPEN_EDITOR_AT_INDEX_COMMAND_ID + visibleIndex, </ins> weight: KeybindingWeight.WorkbenchContrib, when: void 0, primary: KeyMod.Alt | toKeyCode(visibleIndex), mac: { primary: KeyMod.WinCtrl | toKeyCode(visibleIndex) }, <del> handler: accessor => { const editorService = accessor.get(IEditorService); const activeControl = editorService.activeControl; if (activeControl) { const editor = activeControl.group.getEditor(editorIndex); if (editor) { return editorService.openEditor(editor).then(() => void 0); } } return void 0; } </del> <ins> handler: accessor => openEditorAtIndex(accessor, editorIndex) </ins> }); }


if (SnakeCaseAction.caseBoundary.isSupported() && SnakeCaseAction.singleLetters.isSupported()) { registerEditorAction(SnakeCaseAction); } <ins> if (CamelCaseAction.wordBoundary.isSupported()) { registerEditorAction(CamelCaseAction); } </ins> if (TitleCaseAction.titleBoundary.isSupported()) { registerEditorAction(TitleCaseAction); }


onDidChangeShellType: Event<TerminalShellType>; onDidChangeVisibility: Event<boolean>; <ins> onWillPaste: Event<string>; onDidPaste: Event<string>; </ins> /** * An event that fires when a terminal is dropped on this instance via drag and drop. */


this.textArea.setAttribute('aria-label', this._getAriaLabel(options)); this.textArea.setAttribute('tabindex', String(options.get(EditorOption.tabIndex))); <del> if (e.hasChanged(EditorOption.domReadOnly)) { if (options.get(EditorOption.domReadOnly)) { </del> <ins> if (e.hasChanged(EditorOption.domReadOnly) || e.hasChanged(EditorOption.readOnly)) { if (options.get(EditorOption.domReadOnly) && options.get(EditorOption.readOnly)) { </ins> this.textArea.setAttribute('readonly', 'true'); } else { this.textArea.removeAttribute('readonly');


*--------------------------------------------------------------------------------------------*/ import { mapFindFirst } from 'vs/base/common/arraysFind'; <del> import { BugIndicatingError, onUnexpectedExternalError } from 'vs/base/common/errors'; </del> <ins> import { BugIndicatingError, onUnexpectedError, onUnexpectedExternalError } from 'vs/base/common/errors'; </ins> import { Disposable } from 'vs/base/common/lifecycle'; import { IObservable, IReader, ITransaction, autorun, derived, derivedHandleChanges, derivedOpts, recomputeInitiallyAndOnChange, observableSignal, observableValue, subtransaction, transaction } from 'vs/base/common/observable'; import { commonPrefixLength, splitLinesIncludeSeparators } from 'vs/base/common/strings';


private readonly _capabilities: ITerminalCapabilityStore, private readonly _processManager: Pick<ITerminalProcessManager, 'initialCwd' | 'os' | 'remoteAuthority' | 'userHome'> & { backend?: Pick<ITerminalBackend, 'getWslPath'> }, private readonly _linkResolver: ITerminalLinkResolver, <ins> @ILogService private readonly _logService: ILogService, </ins> @IUriIdentityService private readonly _uriIdentityService: IUriIdentityService, @IWorkspaceContextService private readonly _workspaceContextService: IWorkspaceContextService ) {


return undefined; } let targetPlatform = this.extension.gallery.properties.targetPlatform; <del> if (this.extensionManagementServerService.remoteExtensionManagementServer) { </del> <ins> if (targetPlatform !== TargetPlatform.UNIVERSAL && targetPlatform !== TargetPlatform.UNDEFINED && this.extensionManagementServerService.remoteExtensionManagementServer) { </ins> try { const manifest = await this.galleryService.getManifest(this.extension.gallery, CancellationToken.None); if (manifest && this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(manifest)) {


// Diff navigator this.diffNavigator = new DiffNavigator(control, { <del> alwaysRevealFirst: !optionsGotApplied && !hasPreviousViewState // only reveal first change if we had no options or viewstate </del> <ins> alwaysRevealFirst: !optionsGotApplied && !hasPreviousViewState, // only reveal first change if we had no options or viewstate findResultLoop: this.getMainControl()?.getOption(EditorOption.find).loop </ins> }); this.diffNavigatorDisposables.add(this.diffNavigator);


export interface IFileCellEdit { readonly _type: FileEditType.Cell; readonly uri: URI; <del> readonly edit?: ICellPartialMetadataEdit | IDocumentMetadataEdit; </del> <ins> readonly edit?: ICellMetadataEdit | IDocumentMetadataEdit; </ins> readonly notebookMetadata?: Record<string, any>; readonly metadata?: vscode.WorkspaceEditEntryMetadata; }


workspacesToOpen: IWorkspacePathToOpen[], foldersToOpen: ISingleFolderWorkspacePathToOpen[], emptyToRestore: IEmptyWindowBackupInfo[], <del> emptyToOpen: number, </del> <ins> openOneEmptyWindow: boolean, </ins> filesToOpen: IFilesToOpen | undefined, foldersToAdd: ISingleFolderWorkspacePathToOpen[] ): Promise<{ windows: ICodeWindow[]; filesOpenedInWindow: ICodeWindow | undefined }> {


@INativeHostService private readonly nativeHostService: INativeHostService ) { super(ReportExtensionIssueAction._id, ReportExtensionIssueAction._label, 'extension-action report-issue'); <del> this.enabled = !!extension.description.repository && !!extension.description.repository.url; </del> <ins> this.enabled = extension.description.isBuiltin || (!!extension.description.repository && !!extension.description.repository.url); </ins> } async run(): Promise<void> {


description: nls.localize('peekWidgetDefaultFocus', "Controls whether to focus the inline editor or the tree in the peek widget.") } )), <ins> definitionLinkOpensInPeek: register(new EditorBooleanOption( EditorOption.definitionLinkOpensInPeek, 'definitionLinkOpensInPeek', false, { description: nls.localize('definitionLinkOpensInPeek', "Controls whether the definition link opens element in the peek widget.") } )), </ins> quickSuggestions: register(new EditorQuickSuggestions()), quickSuggestionsDelay: register(new EditorIntOption( EditorOption.quickSuggestionsDelay, 'quickSuggestionsDelay',


staleBackupWorkspaces.forEach(staleBackupWorkspace => { const {backupPath, workspaceIdentifier, isEmptyWorkspace} = staleBackupWorkspace; <del> extfs.delSync(backupPath); </del> <ins> try { extfs.delSync(backupPath); } catch (ex) { console.error(`Backup: Could not delete stale backup: ${ex.toString()}`); } </ins> this.removeBackupPathSync(workspaceIdentifier, isEmptyWorkspace); }); }


export const IS_WORKSPACE_SHELL_ALLOWED_STORAGE_KEY = 'terminal.integrated.isWorkspaceShellAllowed'; export const NEVER_SUGGEST_SELECT_WINDOWS_SHELL_STORAGE_KEY = 'terminal.integrated.neverSuggestSelectWindowsShell'; <ins> export const NEVER_MEASURE_RENDER_TIME_STORAGE_KEY = 'terminal.integrated.neverMeasureRenderTime'; </ins> export const ITerminalService = createDecorator<ITerminalService>(TERMINAL_SERVICE_ID);


return data; } else { const result = new _URI(data); <del> result._fsPath = (<UriState>data).fsPath; </del> result._formatted = (<UriState>data).external; <ins> result._fsPath = (<UriState>data)._sep === _pathSepMarker ? (<UriState>data).fsPath : null; </ins> return result; } }


$('div').append($('a').attr('target', '_blank').attr('href', this.requestFeatureLink).text(nls.localize("request a missing feature", "Request a missing feature")).attr('tabindex', '0')) .appendTo($contactUsContainer); <del> let $charCounter = $('span.char-counter').text('(' + FeedbackDropdown.MAX_FEEDBACK_CHARS + ' ' + nls.localize("characters left", "characters left") + ')'); </del> <ins> let $charCounter = $('span.char-counter').text(this.getCharCountText(0)); </ins> $('h3').text(nls.localize("tell us why?", "Tell us why?")) .append($charCounter)


import { MutableDisposable } from 'vs/base/common/lifecycle'; import { IPaneCompositePartService } from 'vs/workbench/services/panecomposite/browser/panecomposite'; import { ViewContainerLocation } from 'vs/workbench/common/views'; <ins> import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; </ins> /** * An implementation of editor for file system resources.


this._cursorBlinking = options.get(EditorOption.cursorBlinking); this._cursorStyle = options.get(EditorOption.cursorStyle); this._cursorSmoothCaretAnimation = options.get(EditorOption.cursorSmoothCaretAnimation); <ins> this._experimentalEditContextEnabled = options.get(EditorOption.experimentalEditContextEnabled); </ins> this._updateBlinking(); this._updateDomClassName();


if (completion.snippetInfo || completion.filterText !== completion.insertText) { // not in WYSIWYG mode, partial commit might change completion, thus it is not supported <del> this.accept(editor); </del> <ins> await this.accept(editor); </ins> return; }


import * as nls from 'vs/nls'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { ILogService } from 'vs/platform/log/common/log'; <ins> import { IUriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentity'; </ins> import { IWorkspaceContextService, IWorkspaceFolderData, toWorkspaceFolder, WorkbenchState } from 'vs/platform/workspace/common/workspace'; import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService'; import { IPathService } from 'vs/workbench/services/path/common/pathService';


<del> <svg xmlns="http://www.w3.org/2000/svg" x="0px" y="0px" width="30" height="42" viewBox="0 0 30 42" style="enable-background:new 0 0 30 42;"><polygon style="fill:#FFFFFF;stroke:#000000;stroke-width:2;" points="29,2.4 3.8,27.6 14.3,27.6 9,38.1 15.4,40.2 20.6,29.7 29,36"/></svg> </del> <ins> <svg xmlns="http://www.w3.org/2000/svg" x="0px" y="0px" width="30" height="50" viewBox="0 0 30 50" style="enable-background:new 0 0 30 50;"><polygon style="fill:#FFFFFF;stroke:#000000;stroke-width:2;" points="29,2.4 3.8,27.6 14,27.6 6.4,43 12.6,45 20.2,29.8 29,36"/></svg> </ins>


contextKeyService: IContextKeyService, options: IWorkbenchListOptions<CellViewModel>, @IListService listService: IListService, <del> @IConfigurationService configurationService: IConfigurationService, </del> <ins> @IConfigurationService private readonly configurationService: IConfigurationService, </ins> @IInstantiationService instantiationService: IInstantiationService ) { super(listUser, container, delegate, renderers, options, contextKeyService, listService, configurationService, instantiationService);


return []; } <ins> if (data.editSession.folders.length === 1) { const folder = data.editSession.folders[0]; return this.getEditSessionFolderContents(ref, folder.name); } </ins> return data.editSession.folders.map((folder) => { const resource = URI.from({ scheme: EDIT_SESSIONS_SCHEME, authority: 'remote-session-content', path: `/${data.ref}/${folder.name}` }); return {


import { Codicon } from 'vs/base/common/codicons'; import { VSCodeOscProperty, VSCodeOscPt, VSCodeSequence } from 'vs/workbench/contrib/terminal/browser/terminalEscapeSequences'; <del> const taskShellIntegrationStartSequence = VSCodeSequence(VSCodeOscPt.PromptStart) + VSCodeSequence(VSCodeOscPt.Property, `${VSCodeOscProperty.Task}=True`) + VSCodeSequence(VSCodeOscPt.CommandStart); const taskShellIntegrationOutputSequence = VSCodeSequence(VSCodeOscPt.CommandExecuted); </del> interface ITerminalData { terminal: ITerminalInstance; lastTask: string;


const arg: contextMenuArg = { source: element.notebook.uri.toString(), <ins> name: element.name, </ins> value: element.value, type: element.type, expression: element.expression,


import { TerminalLink } from 'vs/workbench/contrib/terminal/browser/links/terminalLink'; import { TerminalLinkDetectorAdapter } from 'vs/workbench/contrib/terminal/browser/links/terminalLinkDetectorAdapter'; import { TerminalLocalFileLinkOpener, TerminalLocalFolderInWorkspaceLinkOpener, TerminalLocalFolderOutsideWorkspaceLinkOpener, TerminalSearchLinkOpener, TerminalUrlLinkOpener } from 'vs/workbench/contrib/terminal/browser/links/terminalLinkOpeners'; <del> import { lineAndColumnClause, TerminalLocalLinkDetector, unixLocalLinkClause, winDrivePrefix, winLocalLinkClause } from 'vs/workbench/contrib/terminal/browser/links/terminalLocalLinkDetector'; </del> <ins> import { TerminalLocalLinkDetector, winDrivePrefix } from 'vs/workbench/contrib/terminal/browser/links/terminalLocalLinkDetector'; </ins> import { TerminalUriLinkDetector } from 'vs/workbench/contrib/terminal/browser/links/terminalUriLinkDetector'; import { TerminalWordLinkDetector } from 'vs/workbench/contrib/terminal/browser/links/terminalWordLinkDetector'; import { ITerminalExternalLinkProvider, TerminalLinkQuickPickEvent } from 'vs/workbench/contrib/terminal/browser/terminal';


import { IDimension } from 'vs/editor/common/core/dimension'; import { Position } from 'vs/editor/common/core/position'; import { Range } from 'vs/editor/common/core/range'; <del> import { CursorChangeReason } from 'vs/editor/common/cursorEvents'; </del> <ins> import { CursorChangeReason, ICursorPositionChangedEvent } from 'vs/editor/common/cursorEvents'; </ins> import { IDiffComputationResult, ILineChange } from 'vs/editor/common/diff/legacyLinesDiffComputer'; import { LineRangeMapping, RangeMapping } from 'vs/editor/common/diff/rangeMapping'; import { EditorType, IDiffEditorModel, IDiffEditorViewModel, IDiffEditorViewState } from 'vs/editor/common/editorCommon';


import { EventType, addDisposableListener, addStandardDisposableListener, h } from 'vs/base/browser/dom'; import { createFastDomNode } from 'vs/base/browser/fastDomNode'; import { IMouseWheelEvent } from 'vs/base/browser/mouseEvent'; <ins> import { ScrollbarState } from 'vs/base/browser/ui/scrollbar/scrollbarState'; </ins> import { Color } from 'vs/base/common/color'; import { Disposable } from 'vs/base/common/lifecycle'; import { IObservable, autorun, derived, observableFromEvent, observableSignalFromEvent } from 'vs/base/common/observable';


private provider: IURLCallbackProvider | undefined; constructor( <del> @IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService </del> <ins> @IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService, @IOpenerService openerService: IOpenerService, @IProductService productService: IProductService </ins> ) { super(); this.provider = environmentService.options?.urlCallbackProvider; this.registerListeners(); <ins> const that = this; this._register(openerService.registerOpener({ async open(resource: URI | string) { if (!matchesScheme(resource, productService.urlProtocol)) { return false; } if (typeof resource === 'string') { resource = URI.parse(resource); } return that.open(resource); } })); </ins> } private registerListeners(): void {


const sessionId = viewModel.sessionId; const view = await viewService.openView(widget.viewContext.viewId) as ChatViewPane; <ins> const viewState = view.widget.getViewState(); </ins> view.clear(); <del> await editorService.openEditor({ resource: ChatEditorInput.getNewEditorUri(), options: <IChatEditorOptions>{ target: { sessionId }, pinned: true } }, moveTo === MoveToNewLocation.Window ? AUX_WINDOW_GROUP : ACTIVE_GROUP); </del> <ins> await editorService.openEditor({ resource: ChatEditorInput.getNewEditorUri(), options: <IChatEditorOptions>{ target: { sessionId }, pinned: true, viewState: viewState } }, moveTo === MoveToNewLocation.Window ? AUX_WINDOW_GROUP : ACTIVE_GROUP); </ins> } async function moveToSidebar(accessor: ServicesAccessor): Promise<void> {


// Always fallback to monospace, otherwise a proportional font may become the default fontFamily += ', monospace'; <ins> // Always fallback to AppleBraille on macOS, otherwise braille will render with filled and // empty circles in all 8 positions, instead of just filled circles // See https://github.com/microsoft/vscode/issues/174521 if (isMacintosh) { fontFamily += ', AppleBraille'; } </ins> const letterSpacing = this._terminalConfigurationService.config.letterSpacing ? Math.max(Math.floor(this._terminalConfigurationService.config.letterSpacing), MINIMUM_LETTER_SPACING) : DEFAULT_LETTER_SPACING; const lineHeight = this._terminalConfigurationService.config.lineHeight ? Math.max(this._terminalConfigurationService.config.lineHeight, 1) : DEFAULT_LINE_HEIGHT;


// on the onDidHide event. picker.show(); <del> // If the previous picker had a selection, we should set that in the new picker. if (visibleSelection) { picker.valueSelection = visibleSelection; } </del> // Pick mode: return with promise if (pick) { return pickPromise?.p;


import { Action2, IAction2Options, registerAction2 } from 'vs/platform/actions/common/actions'; import { ServicesAccessor } from 'vs/editor/browser/editorExtensions'; import { localize } from 'vs/nls'; <del> import { IEditSessionsWorkbenchService, Change, ChangeType, Folder, EditSession, FileType, EDIT_SESSION_SYNC_CATEGORY, EDIT_SESSIONS_CONTAINER_ID, EditSessionSchemaVersion, IEditSessionsLogService, EDIT_SESSIONS_VIEW_ICON, EDIT_SESSIONS_TITLE, EDIT_SESSIONS_SCHEME } from 'vs/workbench/contrib/editSessions/common/editSessions'; </del> <ins> import { IEditSessionsWorkbenchService, Change, ChangeType, Folder, EditSession, FileType, EDIT_SESSION_SYNC_CATEGORY, EDIT_SESSIONS_CONTAINER_ID, EditSessionSchemaVersion, IEditSessionsLogService, EDIT_SESSIONS_VIEW_ICON, EDIT_SESSIONS_TITLE, EDIT_SESSIONS_SCHEME, EDIT_SESSIONS_SHOW_VIEW, EDIT_SESSIONS_SIGNED_IN } from 'vs/workbench/contrib/editSessions/common/editSessions'; </ins> import { ISCMRepository, ISCMService } from 'vs/workbench/contrib/scm/common/scm'; import { IFileService } from 'vs/platform/files/common/files'; import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';


DOM.addStandardDisposableListener(inputBox.inputElement, DOM.EventType.KEY_DOWN, (e: IKeyboardEvent) => { if (e.equals(KeyCode.Enter)) { if (inputBox.validate()) { <del> done(true, true); </del> <ins> done(true); </ins> } } else if (e.equals(KeyCode.Escape)) { <del> done(false, true); </del> <ins> done(false); </ins> } }), blurDisposable,


constructor(private _trait: string) { } splice(start: number, deleteCount: number, elements: boolean[]): void { <del> deleteCount = Math.max(0, Math.min(deleteCount, this.length - start)); </del> const diff = elements.length - deleteCount; const end = start + deleteCount; const sortedIndexes: number[] = [];


public removeManualRanges(ranges: ILineRange[]) { const newFoldingRanges: FoldRange[] = new Array(); <del> const containedBy = (foldRange: FoldRange) => { </del> <ins> const intersects = (foldRange: FoldRange) => { </ins> for (const range of ranges) { <del> if (range.startLineNumber <= foldRange.startLineNumber && range.endLineNumber >= foldRange.endLineNumber) { </del> <ins> if (!(range.startLineNumber > foldRange.endLineNumber || foldRange.startLineNumber > range.endLineNumber)) { </ins> return true; } }


return pattern.toUpperCase(); } else if (matches[0].toLowerCase() === matches[0]) { return pattern.toLowerCase(); <del> } else if (strings.containsUppercaseCharacter(matches[0][0])) { </del> <ins> } else if (strings.containsUppercaseCharacter(matches[0][0]) && pattern.length > 0) { </ins> return pattern[0].toUpperCase() + pattern.substr(1); } else { // we don't understand its pattern yet.


} /** <del> * The potential context information for a {@link TextSearchResultNew}. </del> <ins> * The context lines of text that are not a part of a match, * but that surround a match line of type {@link TextSearchMatchNew}. * * For example, consider this excerpt: * * ```ts * const bar = 1; * console.log(bar); * const foo = bar; * ``` * * If the query is `log`, then the lines `const bar = 1;` and `const foo = bar;` * should be represented using two separate {@link TextSearchContextNew} for the search instance. * This example assumes that the finder requests one line of surrounding context. </ins> */ export class TextSearchContextNew { /**


} protected override _resize(size: dom.Dimension): void { <ins> ContentHoverWidget._lastDimensions = new dom.Dimension(size.width, size.height); </ins> this._setAdjustedHoverWidgetDimensions(size); this._resizableNode.layout(size.height, size.width); this._setResizableNodeMaxDimensions();


} } <ins> public copyImage() { if (this.previewState === PreviewState.Active) { this.webviewEditor.reveal(); this.webviewEditor.webview.postMessage({ type: 'copyImage' }); } } </ins> protected override updateState() { super.updateState();


}; if (this._configurationService.getValue(OutlineConfigKeys.problemsEnabled)) { markerServiceListener.value = this._markerService.onMarkerChanged(e => { <ins> if (notebookEditorWidget.isDisposed) { console.error('notebook editor is disposed'); return; } </ins> if (e.some(uri => notebookEditorWidget.getCellsInRange().some(cell => isEqual(cell.uri, uri)))) { doUpdateMarker(false); this._onDidChange.fire({});


rimraf "^3.0.2" ws "^6.1.0" <del> playwright@0.15.0: version "0.15.0" resolved "https://registry.yarnpkg.com/playwright/-/playwright-0.15.0.tgz#bf5c3bb8404975aba78459310742388c08438431" integrity sha512-UGHkQz8DT43uJ0KgMh2rmj8BI4FE5ReQJ9nm5mG68tt1Cj2sXPdM2b05qptfYYBPtQRetQqtJTauZ6rlCDemaQ== </del> <ins> playwright@1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/playwright/-/playwright-1.0.1.tgz#326d479829a3505799ddc9988cc8decf5a7f8376" integrity sha512-kVTE7uvZ7OcDVOBx7MVArUm2nbzzzpauKV9tuVIAH6vWGsOWbGGALUoTWMzNDzsPPTBJXXmxzC4KgI2zN+kVhw== </ins> dependencies: <del> playwright-core "=0.15.0" </del> <ins> playwright-core "=1.0.1" </ins> plist@^3.0.1: version "3.0.1"


if (showResult.choice === 0) { invokeProtocolHandler(); } else if (showResult.choice === 1) { <del> await this.openerService.open(URI.parse(`http://aka.ms/vscode-install`)); </del> <ins> // Route the user to the appropriate install link await this.openerService.open(URI.parse( this.productService.quality === 'stable' ? `http://aka.ms/vscode-install` : `http://aka.ms/vscode-install-insiders` )); // Re-show the dialog so that the user can come back after installing and try again showProtocolUrlOpenedDialog(); </ins> } <ins> }; // We cannot know whether the protocol handler succeeded. // Display guidance in case it did not, e.g. the app is not installed locally. if (matchesScheme(href, this.productService.urlProtocol)) { await showProtocolUrlOpenedDialog(); </ins> } }


this._register(editorService.onDidActiveEditorChange(() => { disposables.clear(); <del> const editorControl = this.editorService.activeTextEditorControl; </del> <ins> let editorControl = this.editorService.activeTextEditorControl; if (isDiffEditor(editorControl)) { editorControl = editorControl.getModifiedEditor(); } </ins> if (isCodeEditor(editorControl)) { disposables.add(editorControl.onDidChangeModelLanguage(setContextKey)); }


workspace.folders.some(folder => uriIdentityService.extUri.isEqual(folder.uri, resource)) // Need to verify resources are workspaces since multi selection can trigger this command on some non workspace resources ); <ins> if (resources.length === 0) { const commandService = accessor.get(ICommandService); // Show a picker for the user to choose which folder to remove return commandService.executeCommand(RemoveRootFolderAction.ID); } </ins> return workspaceEditingService.removeFolders(resources); } });


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


dependencies: is-number "^7.0.0" <del> typescript@5.4.3: version "5.4.3" resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.4.3.tgz#5c6fedd4c87bee01cd7a528a30145521f8e0feff" integrity sha512-KrPd3PKaCLr78MalgiwJnA25Nm8HAmdwN3mYUYZgG/wizIo9EainNVQI9/yDavtVFRN2h3k8uf3GLHuhDMgEHg== </del> <ins> typescript@5.4.4: version "5.4.4" resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.4.4.tgz#eb2471e7b0a5f1377523700a21669dce30c2d952" integrity sha512-dGE2Vv8cpVvw28v8HCPqyb08EzbBURxDpuhJvTrusShUfGnhHBafDsLdS1EhhxyL6BJQE+2cT3dDPAv+MQ6oLw== </ins> vscode-grammar-updater@^1.1.0: version "1.1.0"


} } <ins> // Mimic option first character navigation of native select private onCharacter(e: StandardKeyboardEvent): void { const ch = KeyCodeUtils.toString(e.keyCode); let optionIndex = -1; for (let i = 0; i < this.options.length - 1; i++) { optionIndex = (i + this.selected + 1) % this.options.length; if (this.options[optionIndex].charAt(0).toUpperCase() === ch) { this.select(optionIndex); this.selectList.setFocus([optionIndex]); this.selectList.reveal(this.selectList.getFocus()[0]); dom.EventHelper.stop(e); break; } } } </ins> public dispose(): void { this.toDispose = dispose(this.toDispose); }


{ label: 'aa', reason: TestResultItemChangeReason.OwnStateChange }, { label: 'root', reason: TestResultItemChangeReason.ComputedStateChange }, ]); <ins> r.updateState(testId, 't', TestResultState.Passed); assert.deepStrictEqual(r.getStateById(testId)?.ownComputedState, TestResultState.Passed); r.updateState(testId, 't', TestResultState.Errored); assert.deepStrictEqual(r.getStateById(testId)?.ownComputedState, TestResultState.Errored); r.updateState(testId, 't', TestResultState.Passed); assert.deepStrictEqual(r.getStateById(testId)?.ownComputedState, TestResultState.Errored); </ins> }); test('retire', () => {


if (this._formatted) { res.external = this._formatted; } <del> // uri components </del> <ins> //--- uri components </ins> if (this.path) { res.path = this.path; } <ins> // TODO // this isn't correct and can violate the UriComponents contract but // this is part of the vscode.Uri API and we shouldn't change how that // works anymore </ins> if (this.scheme) { res.scheme = this.scheme; }


async function openVscodeDevLink(gitAPI: GitAPI): Promise<vscode.Uri | undefined> { try { <del> const headlink = await getLink(gitAPI, true, getVscodeDevHost(), 'headlink'); </del> <ins> const headlink = await getLink(gitAPI, true, false, getVscodeDevHost(), 'headlink'); </ins> return headlink ? vscode.Uri.parse(headlink) : undefined; } catch (err) { if (!(err instanceof vscode.CancellationError)) {