if (!item.completion.command) { // done this.model.cancel(); <del> this.model.clear(); </del> } else if (item.completion.command.id === TriggerSuggestAction.id) { // retigger


resolved "https://registry.yarnpkg.com/xterm-addon-unicode11/-/xterm-addon-unicode11-0.5.0.tgz#41c0d96acc1e3bb6c6596eee64e163b6bca74be7" integrity sha512-Jm4/g4QiTxiKiTbYICQgC791ubhIZyoIwxAIgOW8z8HWFNY+lwk+dwaKEaEeGBfM48Vk8fklsUW9u/PlenYEBg== <del> xterm-addon-webgl@0.15.0-beta.8: version "0.15.0-beta.8" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.15.0-beta.8.tgz#2005198582f6f1f4a9b2612b9354c0bcc9f148d8" integrity sha512-HjTr9bi3FvdOIPaaIpih6qdHX2z+H7sQPluLj5KzwCqRiEVUVRi19dl8SdHjf6dCmN3GahMhjV7D+zxHi2pLTw== </del> <ins> xterm-addon-webgl@0.15.0-beta.10: version "0.15.0-beta.10" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.15.0-beta.10.tgz#39ebbfb1b89c6773a2d8cb8e1d2f3ef1f08b28f9" integrity sha512-JVv4t5q6QGWyLiEAcAk9H2B83hFlIalzEwWu1VVYso0MJyZAlZ0NP5Za03iSKxYi7RQIA5bOe8r7W24esQDjLg== </ins> <del> xterm-headless@5.2.0-beta.35: version "5.2.0-beta.35" resolved "https://registry.yarnpkg.com/xterm-headless/-/xterm-headless-5.2.0-beta.35.tgz#8c3d4d06747e27a5bc4f0bf914479820a5b8f529" integrity sha512-tq/zKnXEsVXGlhXHGNqPO47x9Fvew2avZ0wfMI1G80AEYrjxGY/3Quxwe9/C5ngIuPwk2CMbgDZwHhSFvyOrMA== </del> <ins> xterm-headless@5.2.0-beta.40: version "5.2.0-beta.40" resolved "https://registry.yarnpkg.com/xterm-headless/-/xterm-headless-5.2.0-beta.40.tgz#6edba318d23ed350c8ec6279e6f61f40bde9b163" integrity sha512-6CHgR64POfa24CTILcq/HHg1im1u1HjJZSHWjlopP18KiS8Rq8dzCurZDsu38atxDK9dyjV8SRw2AB4ijcxZsQ== </ins> <del> xterm@5.2.0-beta.35: version "5.2.0-beta.35" resolved "https://registry.yarnpkg.com/xterm/-/xterm-5.2.0-beta.35.tgz#4a0c0aa81c89c42167c22d023648cced44fa3c25" integrity sha512-6x6i61lucRrLWRKFeMO/ZOx5anvYR6FHpReLO2g0y1bp5zYWyZFzM6DepMV50729gubzxSLB8mvbmb9EpeIugQ== </del> <ins> xterm@5.2.0-beta.40: version "5.2.0-beta.40" resolved "https://registry.yarnpkg.com/xterm/-/xterm-5.2.0-beta.40.tgz#c73d5576425dcd4fa6b48ce58b4224a7b5b9dbdf" integrity sha512-7/Db3KPceM0VX4/YAKL+/ArvEHlGBwE3kt1oN9QP5TLaJ6r2ThMS7z7QwG8g2gy60GFnvjfvpcTv6Ewyste4zg== </ins> y18n@^3.2.1: version "3.2.2"


import { FontMeasurements } from 'vs/editor/browser/config/fontMeasurements'; import { IEditorOptions } from 'vs/editor/common/config/editorOptions'; import { BareFontInfo } from 'vs/editor/common/config/fontInfo'; <del> import { IConfigurationChangeEvent, IConfigurationService } from 'vs/platform/configuration/common/configuration'; </del> <ins> import { ConfigurationTarget, IConfigurationChangeEvent, IConfigurationService } from 'vs/platform/configuration/common/configuration'; </ins> import { InteractiveWindowCollapseCodeCells, NotebookCellDefaultCollapseConfig, NotebookCellInternalMetadata, NotebookSetting, ShowCellStatusBarType } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { INotebookExecutionStateService } from 'vs/workbench/contrib/notebook/common/notebookExecutionStateService';


"hasInstallScript": true }, "node_modules/@xterm/addon-clipboard": { <del> "version": "0.2.0-beta.39", "resolved": "https://registry.npmjs.org/@xterm/addon-clipboard/-/addon-clipboard-0.2.0-beta.39.tgz", "integrity": "sha512-PeJZP69FHg2p1NJKLGyqUITahvEexqwYoQAgYheu4d9UBhIdP6D/KWGT8DVAEPeeulXhcr2UXgYWMVQAooTvrw==", </del> <ins> "version": "0.2.0-beta.47", "resolved": "https://registry.npmjs.org/@xterm/addon-clipboard/-/addon-clipboard-0.2.0-beta.47.tgz", "integrity": "sha512-mJHV1770gwVckj4mgjdxegt4zLL5WGCoJblTqaLbgEF7xOwsJUzvGk38qsZ4ZpdTa2ti76H0pkb1CpZGrXL9qg==", </ins> "dependencies": { "js-base64": "^3.7.5" }, "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/addon-image": { <del> "version": "0.9.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/addon-image/-/addon-image-0.9.0-beta.56.tgz", "integrity": "sha512-kwE4ZDlPxXsBk4mnQoqMvSwu9aKQclniIybs90t0L2qGPLcI8/7Akm1i9aXbu8eZF2hoLEPfLC3CZPda+4ioOA==", </del> <ins> "version": "0.9.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/addon-image/-/addon-image-0.9.0-beta.64.tgz", "integrity": "sha512-1Aqqytx/z/Khecf5xrO++f/p5EQX4uG87TbbAmE0OQys/JgKMnNggDzqon5bpHboimLfQiFPw716NbTqMphjfw==", </ins> "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/addon-search": { <del> "version": "0.16.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/addon-search/-/addon-search-0.16.0-beta.56.tgz", "integrity": "sha512-f8aoldPGssse1UR2N3f94fRUc7K3eulb+F80MFhim4rP+shX3QO9QdEZtwr+JaPEujjnuBM5tQKQDuRQtbwuMQ==", </del> <ins> "version": "0.16.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/addon-search/-/addon-search-0.16.0-beta.64.tgz", "integrity": "sha512-vUsvTkEOFJwv8nVtiiGr/vTMeQhu62VkUejY2h1+yZagnVEusGVPU1JYoqBTLu5HM4cFiTGsJYXFI/0apASXYA==", </ins> "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/addon-serialize": { <del> "version": "0.14.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/addon-serialize/-/addon-serialize-0.14.0-beta.56.tgz", "integrity": "sha512-VGAYJXFfXuY1Ze8CliT28DoYI74s8fdTI9919C0sgWwtzfAa7W43jJ56g0oKVEM0wO20wfdESapwpQ7enMzrHQ==", </del> <ins> "version": "0.14.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/addon-serialize/-/addon-serialize-0.14.0-beta.64.tgz", "integrity": "sha512-0AqVveTV3Pr9Lp+beJYOP5WuRvIrPSDGAK24da7BRGcLIKVq8pok1FdlM9jPeUbkX0DKo6Ortm77qeb2Z+n8+A==", </ins> "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/addon-unicode11": { <del> "version": "0.9.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/addon-unicode11/-/addon-unicode11-0.9.0-beta.56.tgz", "integrity": "sha512-oWa8xLWMDKgJboqOT57PaNAWYz+2INW5aUc24E0Nzv+gKXVy+8lRoqy50m3DhsOb1YtDaPVloqvambKBaXSing==", </del> <ins> "version": "0.9.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/addon-unicode11/-/addon-unicode11-0.9.0-beta.64.tgz", "integrity": "sha512-3+PKu+DXFq32xlsYfnI058/T8dTY2tQhRpJLP2CNR/jVWk5uBkVO0dBV0Srqj5QOAlAhzzZuS6TbsVRXORptqw==", </ins> "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/addon-webgl": { <del> "version": "0.19.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/addon-webgl/-/addon-webgl-0.19.0-beta.56.tgz", "integrity": "sha512-aYNRENPJBb1uoV7QifEwCnbjCXmQD5yQmuxNJab3bOZ68aCSGC/EKc4/4Ov0klkXi8ceF4ZnbNiqAX3jw5L1jg==", </del> <ins> "version": "0.19.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/addon-webgl/-/addon-webgl-0.19.0-beta.64.tgz", "integrity": "sha512-cxTkMPAXPQAZnWqahNu7ff9mbJvM1sQqKnZWiFZAHTsZXym4oa3KCB4pjH4didSyYkhkPY/17E8I0UOUpvv0Yw==", </ins> "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/headless": { <del> "version": "5.6.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/headless/-/headless-5.6.0-beta.56.tgz", "integrity": "sha512-aQOCzFDn/yqdATwf+ho1q5Hu2MzQwnXHgcsVx/qwUit/URKgbp1QyOQom88nzprP6D/59tiSeX+tqUS1HPqwMw==" </del> <ins> "version": "5.6.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/headless/-/headless-5.6.0-beta.64.tgz", "integrity": "sha512-my08kgH2K3CBEtBg/o8lamtD6BYNBv03Akq747Lajv0QzOiwan7B4r2xdbA6i9sovB+MdjFs0XP1ksc3EpKakg==" </ins> }, "node_modules/@xterm/xterm": { <del> "version": "5.6.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/xterm/-/xterm-5.6.0-beta.56.tgz", "integrity": "sha512-gtLrCQNkF1LikB21Bj9JYiBrrXMMvPEZkOIiA7MlXoSd7T7v+GYPumrODB2SBuhPdZ8N66z2rbUOfSRzxGwMtA==" </del> <ins> "version": "5.6.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/xterm/-/xterm-5.6.0-beta.64.tgz", "integrity": "sha512-iSKS6tQTFpoN5y487eptlxkUT0jqK5hrvtFQMLugMcQdn7gCUCiFGa4Z1RdqKYSGvAypka+b9gMKPrKWZ7Q3yQ==" </ins> }, "node_modules/agent-base": { "version": "7.1.1",


{ actionViewItemProvider: action => this.actionViewItemProvider(action as Action), actionRunner: this.actionRunner, <del> classNames: 'toolbar-toggle-pickReactions', </del> <ins> classNames: ['toolbar-toggle-pickReactions', ...Codicon.reactions.classNamesArray], </ins> anchorAlignmentProvider: () => AnchorAlignment.RIGHT } );


description: localize('chatSampleRequest', "When the user clicks this participant in `/help`, this text will be submitted to the participant."), type: 'string' }, <ins> when: { description: localize('chatParticipantWhen', "A condition which must be true to enable this participant."), type: 'string' }, </ins> commands: { markdownDescription: localize('chatCommandsDescription', "Commands available for this chat participant, which the user can invoke with a `/`."), type: 'array',


value: this.state.text.value, placeholderText: localize('testExplorerFilter', "Filter (e.g. text, !exclude, @tag)"), }, <del> history: this.history.get([]) </del> <ins> history </ins> })); this._register(attachSuggestEnabledInputBoxStyler(input, this.themeService));


} } <del> // Clear attrs, reset cursor position, clear right </del> <ins> // Get the line content of the command from the terminal </ins> const content = this._serializeAddon.serialize({ range: { start: stickyScrollLineStart + rowOffset,


* interval. */ KillSpawnSpacingDuration = 50, <del> /** * Writing large amounts of data can be corrupted for some reason, after looking into this is * appears to be a race condition around writing to the FD which may be based on how powerful * the hardware is. The workaround for this is to space out when large amounts of data is being * written to the terminal. See https://github.com/microsoft/vscode/issues/38137 */ WriteMaxChunkSize = 50, </del> /** * How long to wait between chunk writes. */


storageId: 'workbench.explorer.views.state', icon: explorerViewIcon, alwaysUseContainerInfo: true, <ins> hideIfEmpty: true, </ins> order: 0, openCommandActionDescriptor: { id: VIEWLET_ID,


if($set.Add($artifactName)) { Write-Host "Processing artifact: '$artifactName. Downloading from: $($_.resource.downloadUrl)" <ins> $extractPath = "$env:AGENT_TEMPDIRECTORY/$artifactName.zip" </ins> try { <del> Invoke-RestMethod $_.resource.downloadUrl -OutFile "$env:AGENT_TEMPDIRECTORY/$artifactName.zip" -Headers @{ </del> <ins> Invoke-RestMethod $_.resource.downloadUrl -OutFile $extractPath -Headers @{ </ins> Authorization = "Bearer $env:SYSTEM_ACCESSTOKEN" <del> } -MaximumRetryCount 5 -RetryIntervalSec 1  | Out-Null </del> <ins> } -MaximumRetryCount 5 -RetryIntervalSec 1 -TimeoutSec 300 | Out-Null </ins> <del> Expand-Archive -Path "$env:AGENT_TEMPDIRECTORY/$artifactName.zip" -DestinationPath $env:AGENT_TEMPDIRECTORY | Out-Null </del> <ins> Write-Host "Extracting artifact: '$extractPath'" Expand-Archive -Path $extractPath -DestinationPath $env:AGENT_TEMPDIRECTORY | Out-Null </ins> } catch { Write-Warning $_ $set.Remove($artifactName) | Out-Null


item: { command: { id: TerminalCommandId.SelectDefaultProfile, <del> title: { value: localize('workbench.action.terminal.selectDefaultProfile', "Select Default Profile"), original: 'Select Default Profile' } </del> <ins> title: { value: localize('workbench.action.terminal.selectDefaultProfile', "Select Default Profile"), original: 'Select Default Profile' }, </ins> }, <del> group: TerminalTabContextMenuGroup.Configure </del> <ins> group: '3_configure' </ins> } }, {


const content = []; content.push(this._descriptionForCommand(TerminalCommandId.FocusAccessibleBuffer, localize('focusAccessibleTerminalView', 'The Focus Accessible Terminal View ({0}) command enables screen readers to read terminal contents.'), localize('focusAccessibleTerminalViewNoKb', 'The Focus Terminal Accessible View command enables screen readers to read terminal contents and is currently not triggerable by a keybinding.'))); content.push(localize('preserveCursor', 'Customize the behavior of the cursor when toggling between the terminal and accessible view with `terminal.integrated.accessibleViewPreserveCursorPosition.`')); <ins> if (!this._configurationService.getValue(TerminalSettingId.AccessibleViewFocusOnCommandExecution)) { content.push(localize('focusViewOnExecution', 'Enable `terminal.integrated.accessibleViewFocusOnCommandExecution` to automatically focus the terminal accessible view when a command is executed in the terminal.')); } </ins> if (this._instance.shellType === WindowsShellType.CommandPrompt) { content.push(localize('commandPromptMigration', "Consider using powershell instead of command prompt for an improved experience")); }


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


templateData.actionBar.context = <TreeViewItemHandleArg>{ $treeViewId: this.treeViewId, $treeItemHandle: node.handle }; <del> const menuActions = this.menus.getResourceActions(node); if (menuActions.menu) { templateData.elementDisposable.add(menuActions.menu); } </del> <ins> const menuActions = this.menus.getResourceActions(node, templateData.elementDisposable); </ins> templateData.actionBar.push(menuActions.actions, { icon: true, label: false }); if (this._actionRunner) {


transformOptimization: false, //(isMacintosh && isNative) || getTitleBarStyle(this.configurationService, this.environmentService) === 'native', initialSize: this._dimension, styleController: (_suffix: string) => { return this._list; }, <del> overrideStyles: this._listStyleOverride, </del> <ins> overrideStyles: { listBackground: notebookEditorBackground, listActiveSelectionBackground: notebookEditorBackground, listActiveSelectionForeground: foreground, listFocusAndSelectionBackground: notebookEditorBackground, listFocusAndSelectionForeground: foreground, listFocusBackground: notebookEditorBackground, listFocusForeground: foreground, listHoverForeground: foreground, listHoverBackground: notebookEditorBackground, listHoverOutline: focusBorder, listFocusOutline: focusBorder, listInactiveSelectionBackground: notebookEditorBackground, listInactiveSelectionForeground: foreground, listInactiveFocusBackground: notebookEditorBackground, listInactiveFocusOutline: notebookEditorBackground, }, </ins> accessibilityProvider: { getAriaLabel: (element: CellViewModel) => { if (!this.viewModel) {


*--------------------------------------------------------------------------------------------*/ import { DataTransfers, IDragAndDropData } from 'vs/base/browser/dnd'; <del> import { $, addDisposableListener, animate, Dimension, getContentHeight, getContentWidth, getTopLeftOffset, getWindow, isAncestor, isHTMLElement, scheduleAtNextAnimationFrame } from 'vs/base/browser/dom'; </del> <ins> import { $, addDisposableListener, animate, Dimension, getContentHeight, getContentWidth, getTopLeftOffset, getWindow, isAncestor, isHTMLElement, isSVGElement, scheduleAtNextAnimationFrame } from 'vs/base/browser/dom'; </ins> import { DomEmitter } from 'vs/base/browser/event'; import { IMouseWheelEvent } from 'vs/base/browser/mouseEvent'; import { EventType as TouchEventType, Gesture, GestureEvent } from 'vs/base/browser/touch';


} private async enterProfile(profile: IUserDataProfile, preserveData: boolean, reloadMessage?: string): Promise<void> { <del> if (this.environmentService.remoteAuthority) { </del> <ins> const isRemoteWindow = !!this.environmentService.remoteAuthority; if (!isRemoteWindow) { this.extensionService.stopExtensionHosts(); } // In a remote window update current profile before reloading so that data is preserved from current profile if asked to preserve await this.userDataProfileService.updateCurrentProfile(profile, preserveData); if (isRemoteWindow) { </ins> const result = await this.dialogService.confirm({ type: 'info', message: reloadMessage ?? localize('reload message', "Switching a settings profile requires reloading VS Code."),


identityProvider: new FileIdentityProvider(), keyboardNavigationLabelProvider: new FileNavigationLabelProvider(), accessibilityProvider: this._instantiationService.createInstance(FileAccessibilityProvider), <ins> showNotFoundMessage: false, </ins> overrideStyles: { listBackground: breadcrumbsPickerBackground },


this._register(this.tree.onDidChangeContentHeight(() => { if (this.tree.scrollHeight !== this.previousTreeScrollHeight) { <del> const lastElementWasVisible = this.tree.scrollTop + this.tree.renderHeight >= this.previousTreeScrollHeight; </del> <ins> // Due to rounding, the scrollTop + renderHeight will not exactly match the scrollHeight. // Consider the tree to be scrolled all the way down if it is within 2px of the bottom. const lastElementWasVisible = this.tree.scrollTop + this.tree.renderHeight >= this.previousTreeScrollHeight - 2; </ins> if (lastElementWasVisible) { setTimeout(() => { // Can't set scrollTop during this event listener, the list might overwrite the change


.pipe(replace('@@LICENSE@@', product.licenseName)) .pipe(rename('usr/share/appdata/' + product.applicationName + '.appdata.xml')); <ins> const workspaceMime = gulp.src('resources/code-workspace.xml', { base: '.' }) .pipe(replace('@@NAME_LONG@@', product.nameLong)) .pipe(replace('@@NAME@@', product.applicationName)) .pipe(rename('usr/share/mime/packages/' + product.applicationName + '-workspace.xml')); </ins> const icon = gulp.src('resources/linux/code.png', { base: '.' }) .pipe(rename('usr/share/pixmaps/' + product.linuxIconName + '.png'));


}, "brackets": [ ["<!--", "-->"], <del> ["<", ">"], </del> ["{", "}"], ["(", ")"] ],


let ranges: Range[] | undefined; for (const placeholder of placeholdersWithEqualIndex) { <ins> if (placeholder.isFinalTabstop) { // ignore those break; } </ins> if (!ranges) { ranges = [];


icon: new ThemeIcon('cloud') }); break; <ins> case ref.startsWith('tag: refs/tags/'): references.push({ id: ref.substring('tag: '.length), name: ref.substring('tag: refs/tags/'.length), revision: commit.hash, icon: new ThemeIcon('tag') }); break; </ins> } } <del> return references; </del> <ins> return references.sort(compareSourceControlHistoryItemRef); </ins> } private async resolveHEADMergeBase(): Promise<Branch | undefined> {


command: showWindowLogActionId, }, async (progress) => { progress.report({ message: localize('Importing profile', "{0} ({1})...", title, profileTemplate.name) }); <del> const profile = await this.getProfileToImport(profileTemplate, temporaryProfile); if (!profile) { return undefined; } </del> <ins> return this.importAndSwitchWithProgress(profileTemplate, temporaryProfile, extensions, extensionsDisabled, message => progress.report({ message: `${title} (${profileTemplate.name}): ${message}` })); }); } </ins> <del> if (profileTemplate.settings) { progress.report({ message: localize('progress settings', "{0} ({1}): Applying Settings...", title, profileTemplate.name) }); await this.instantiationService.createInstance(SettingsResource).apply(profileTemplate.settings, profile); } if (profileTemplate.keybindings) { progress.report({ message: localize('progress keybindings', "{0} ({1}): Applying Keyboard Shortcuts...", title, profileTemplate.name) }); await this.instantiationService.createInstance(KeybindingsResource).apply(profileTemplate.keybindings, profile); } if (profileTemplate.tasks) { progress.report({ message: localize('progress tasks', "{0} ({1}): Applying Tasks...", title, profileTemplate.name) }); await this.instantiationService.createInstance(TasksResource).apply(profileTemplate.tasks, profile); } if (profileTemplate.snippets) { progress.report({ message: localize('progress snippets', "{0} ({1}): Applying Snippets...", title, profileTemplate.name) }); await this.instantiationService.createInstance(SnippetsResource).apply(profileTemplate.snippets, profile); } if (profileTemplate.globalState) { progress.report({ message: localize('progress global state', "{0} ({1}): Applying State...", title, profileTemplate.name) }); await this.instantiationService.createInstance(GlobalStateResource).apply(profileTemplate.globalState, profile); } if (profileTemplate.extensions && extensions) { progress.report({ message: localize('progress extensions', "{0} ({1}): Applying Extensions...", title, profileTemplate.name) }); await this.instantiationService.createInstance(ExtensionsResource, extensionsDisabled).apply(profileTemplate.extensions, profile); } </del> <ins> private async importAndSwitchWithProgress(profileTemplate: IUserDataProfileTemplate, temporaryProfile: boolean, extensions: boolean, extensionsDisabled: boolean, progress: (message: string) => void): Promise<IUserDataProfile | undefined> { const profile = await this.getProfileToImport(profileTemplate, temporaryProfile); if (!profile) { return undefined; } </ins> <del> progress.report({ message: localize('switching profile', "{0} ({1}): Applying...", title, profileTemplate.name) }); await this.userDataProfileManagementService.switchProfile(profile); return profile; }); </del> <ins> if (profileTemplate.settings) { progress(localize('progress settings', "Applying Settings...")); await this.instantiationService.createInstance(SettingsResource).apply(profileTemplate.settings, profile); } if (profileTemplate.keybindings) { progress(localize('progress keybindings', "{0}ying Keyboard Shortcuts...")); await this.instantiationService.createInstance(KeybindingsResource).apply(profileTemplate.keybindings, profile); } if (profileTemplate.tasks) { progress(localize('progress tasks', "Applying Tasks...")); await this.instantiationService.createInstance(TasksResource).apply(profileTemplate.tasks, profile); } if (profileTemplate.snippets) { progress(localize('progress snippets', "Applying Snippets...")); await this.instantiationService.createInstance(SnippetsResource).apply(profileTemplate.snippets, profile); } if (profileTemplate.globalState) { progress(localize('progress global state', "Applying State...")); await this.instantiationService.createInstance(GlobalStateResource).apply(profileTemplate.globalState, profile); } if (profileTemplate.extensions && extensions) { progress(localize('progress extensions', "Applying Extensions...")); await this.instantiationService.createInstance(ExtensionsResource, extensionsDisabled).apply(profileTemplate.extensions, profile); } progress(localize('switching profile', " Applying...")); await this.userDataProfileManagementService.switchProfile(profile); return profile; </ins> } private async resolveProfileContent(resource: URI): Promise<string | null> {


this._primaryAction = new MenuEntryActionViewItem(primaryAction, undefined, _keybindingService, _notificationService, _contextKeyService, _themeService, _contextMenuProvider); this._dropdown = new DropdownMenuActionViewItem(dropdownAction, dropdownMenuActions, this._contextMenuProvider, { menuAsChild: true, <del> classNames: ['codicon', 'codicon-chevron-down'], </del> <ins> classNames: ['codicon', 'codicon-chevron-down', className], </ins> keybindingProvider: this._options?.getKeyBinding }); }


@ILogService private readonly logService: ILogService, @IWorkspacesManagementMainService private readonly workspacesManagementMainService: IWorkspacesManagementMainService, @ILifecycleMainService private readonly lifecycleMainService: ILifecycleMainService, <del> @IApplicationStorageMainService private readonly applicationStorageMainService: IApplicationStorageMainService </del> <ins> @IApplicationStorageMainService private readonly applicationStorageMainService: IApplicationStorageMainService, @IDialogMainService private readonly dialogMainService: IDialogMainService </ins> ) { super();


} const commandService = accessor.get(ICommandService); <ins> const logService = accessor.get(ILogService); let i = 0; </ins> try { <del> for (const cmd of args.commands) { await this._runCommand(commandService, cmd); </del> <ins> for (; i < args.commands.length; ++i) { const cmd = args.commands[i]; logService.debug(`runCommands: executing ${i}-th command: ${JSON.stringify(cmd)}`); const r = await this._runCommand(commandService, cmd); logService.debug(`runCommands: executed ${i}-th command with return value: ${JSON.stringify(r)}`); </ins> } } catch (err) { <ins> logService.debug(`runCommands: executing ${i}-th command resulted in an error: ${err instanceof Error ? err.message : JSON.stringify(err)}`); </ins> notificationService.error(err); } }


* @return A human-readable string which is presented as diagnostic message. * Return `undefined`, `null`, or the empty string when 'value' is valid. */ <del> validateInput?(value: string): string | undefined | null | Thenable<string | undefined | null>; </del> <ins> validateInput?(value: string): string | InputBoxValidationMessage | undefined | null | Thenable<string | InputBoxValidationMessage | undefined | null>; </ins> } /**


.suggest-input-container .monaco-editor, .suggest-input-container .monaco-editor .lines-content { <del> background: none; </del> <ins> background: none !important; </ins> }


registerThemingParticipant((theme, collector) => { let rulerColor = theme.getColor(editorRuler); if (rulerColor) { <del> collector.addRule(`.monaco-editor .view-ruler { background-color: ${rulerColor}; }`); </del> <ins> collector.addRule(`.monaco-editor .view-ruler { --box-shadow-color: ${rulerColor}; }`); </ins> } });


@IWorkbenchEnvironmentService private readonly environmentService: IWorkbenchEnvironmentService, @IProductService private readonly productService: IProductService, @IEditorGroupsService private readonly editorGroupService: IEditorGroupsService, <ins> @IEditorService private readonly editorService: IEditorService, </ins> @IWorkbenchLayoutService private readonly layoutService: IWorkbenchLayoutService, @IPaneCompositePartService private readonly paneCompositeService: IPaneCompositePartService, @IWorkingCopyService private readonly workingCopyService: IWorkingCopyService,


}); return true; })); <ins> this._register(AccessibilityHelpAction.addImplementation(115, 'accessible-view', accessor => { accessor.get(IAccessibleViewService).showAccessibleViewHelp(); return true; }, accessibleViewIsShown)); </ins> } }


*/ sticky?: boolean; /** <ins> * Controls how long the hover is visible after you hovered out of it. * Require sticky setting to be true. */ hidingDelay?: number; /** </ins> * Should the hover be shown above the line if possible? * Defaults to false. */


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


this._findInput = this._register(new ContextScopedFindInput(null, this._contextViewService, { label: NLS_FIND_INPUT_LABEL, placeholder: NLS_FIND_INPUT_", <ins> validation: (value: string): InputBoxMessage | null => { if (value.length === 0 || !this._findInput.getRegex()) { return null; } try { /* tslint:disable-next-line:no-unused-expression */ new RegExp(value); return null; } catch (e) { return { content: e.message }; } } </ins> }, contextKeyService, showOptionButtons)); // Find History with update delayer


import { IExtensionRecommendationNotificationService, RecommendationsNotificationResult, RecommendationSource } from 'vs/platform/extensionRecommendations/common/extensionRecommendations'; import { distinct } from 'vs/base/common/arrays'; import { DisposableStore } from 'vs/base/common/lifecycle'; <ins> import { CellUri } from 'vs/workbench/contrib/notebook/common/notebookCommon'; </ins> type FileExtensionSuggestionClassification = { userReaction: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };


} else { type = TerminalBuiltinLinkType.LocalFile; } <ins> // Offset the buffer range if the link range was trimmed const trimRange = trimRangeMap.get(linkStat.link); if (trimRange) { bufferRange.end.x -= trimRange; if (bufferRange.end.x < 0) { bufferRange.end.y--; bufferRange.end.x += this.xterm.cols; } } </ins> links.push({ text: linkStat.link, uri: linkStat.uri,


if (profile && !profile.isTransient && this.newProfileElement) { this.removeNewProfile(); <del> this.onDidChangeProfiles({ added: [profile], removed: [], updated: [], all: this.userDataProfilesService.profiles }); </del> <ins> const existing = this._profiles.find(([p]) => p.name === profile.name); if (existing) { this._onDidChange.fire(existing[0]); } else { this.onDidChangeProfiles({ added: [profile], removed: [], updated: [], all: this.userDataProfilesService.profiles }); } </ins> } return profile;


id: FOCUS_OUT_OUTPUT_COMMAND_ID, title: localize('focusOutputOut', 'Focus Out Active Cell Output'), keybinding: { <del> when: NOTEBOOK_EDITOR_FOCUSED, </del> <ins> when: ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_OUTPUT_FOCUSED), </ins> primary: KeyMod.CtrlCmd | KeyCode.UpArrow, mac: { primary: KeyMod.WinCtrl | KeyMod.CtrlCmd | KeyCode.UpArrow, }, weight: KeybindingWeight.WorkbenchContrib


if (!isUndefined(e.enabled)) { button.enabled = action.enabled; } <ins> if (!isUndefined(e.label)) { button.label = action.label; } </ins> })); } }


import { IWorkbenchExtensionEnablementService, EnablementState } from 'vs/workbench/services/extensionManagement/common/extensionManagement'; import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil'; import { createDecorator, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation'; <del> import { INotificationService, Severity } from 'vs/platform/notification/common/notification'; </del> <ins> import { INotificationService } from 'vs/platform/notification/common/notification'; </ins> import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage'; import { IURLHandler, IURLService, IOpenURLOptions } from 'vs/platform/url/common/url'; import { IHostService } from 'vs/workbench/services/host/browser/host'; <del> import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions'; </del> <ins> import { IExtensionService, toExtensionDescription } from 'vs/workbench/services/extensions/common/extensions'; </ins> import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions'; import { registerSingleton } from 'vs/platform/instantiation/common/extensions'; import { Registry } from 'vs/platform/registry/common/platform';


this.enabledDisposables.dispose(); this.enabledDisposables = new DisposableStore(); <ins> this.previousPattern = this.pattern; </ins> this.onDidChangeValue(''); this.tree.domFocus();


// Only allow history navigation when the input is empty. // (If this model change happened as a result of a history navigation, this is canceled out by a call in this.navigateHistory) const model = this._inputEditor.getModel(); <del> const inputHasText = !!model && model.getValueLength() > 0; </del> <ins> const inputHasText = !!model && model.getValue().trim().length > 0; </ins> this.inputEditorHasText.set(inputHasText); // If the user is typing on a history entry, then reset the onHistoryEntry flag so that history navigation can be disabled


constructor() { super({ <del> id: 'workbench.action.clearCommandHistory', title: { value: localize('clearCommandHistory', "Clear Command History"), original: 'Clear Command History' }, </del> <ins> id: 'workbench.action.clearPreviousSessionCommandHistory', title: { value: localize('clearPreviousSessionCommandHistory', "Clear Previous Session Command History"), original: 'Clear Previous Session Command History' }, </ins> f1: true }); }


_classifier = new CharacterClassifier<CharacterClass>(CharacterClass.None); // allow-any-unicode-next-line <del> const FORCE_TERMINATION_CHARACTERS = ', t<>'"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…'; </del> <ins> const FORCE_TERMINATION_CHARACTERS = ' t<>'"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…'; </ins> for (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) { _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), CharacterClass.ForceTermination); } <del> const CANNOT_END_WITH_CHARACTERS = '.;:'; </del> <ins> const CANNOT_END_WITH_CHARACTERS = '.,;:'; </ins> for (let i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) { _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), CharacterClass.CannotEndIn); }


// "foo",339 // "foo",339:12 // "foo",339.12 <del> `(?::| |['"],)${r()}([:.]${c()})?` + eolSuffix, </del> <ins> // "foo",339.12-14 // "foo",339.12-341.14 `(?::| |['"],)${r()}([:.]${c()}(?:-(?:${re()}.)?${ce()})?)?` + eolSuffix, </ins> // The quotes below are optional          [#171652] // "foo", line 339                        [#40468] // "foo", line 339, col 12


type: AccessibleViewType; } <ins> export const accessibilityHelpIsShown = new RawContextKey<boolean>('accessibilityHelpIsShown', false, true); </ins> class AccessibleView extends Disposable { private _editorWidget: CodeEditorWidget; <ins> private _accessiblityHelpIsShown: IContextKey<boolean>; </ins> get editorWidget() { return this._editorWidget; } private _editorContainer: HTMLElement; <del> private _keyListener: IDisposable | undefined; </del> constructor( @IOpenerService private readonly _openerService: IOpenerService, @IInstantiationService private readonly _instantiationService: IInstantiationService, @IConfigurationService private readonly _configurationService: IConfigurationService, @IModelService private readonly _modelService: IModelService, <del> @IContextViewService private readonly _contextViewService: IContextViewService </del> <ins> @IContextViewService private readonly _contextViewService: IContextViewService, @IContextKeyService private readonly _contextKeyService: IContextKeyService </ins> ) { super(); <ins> this._accessiblityHelpIsShown = accessibilityHelpIsShown.bindTo(this._contextKeyService); </ins> this._editorContainer = document.createElement('div'); this._editorContainer.classList.add('accessible-view'); const codeEditorWidgetOptions: ICodeEditorWidgetOptions = {


})); this._register(this.preview.onScroll((scrollInfo) => { <del> topmostLineMonitor.setPreviousEditorLine(scrollInfo); </del> <ins> topmostLineMonitor.setPreviousStaticEditorLine(scrollInfo); </ins> })); this._register(topmostLineMonitor.onDidChanged(event => {


return this._wordToLineNumbersMap; } <ins> private updateHoverConfiguration(): void { const stackFrame = this.debugService.getViewModel().focusedStackFrame; const model = this.editor.getModel(); if (model) { this.applyHoverConfiguration(model, stackFrame); } } </ins> private applyHoverConfiguration(model: ITextModel, stackFrame: IStackFrame | undefined): void { if (stackFrame && this.uriIdentityService.extUri.isEqual(model.uri, stackFrame.source.uri)) { if (this.altListener) {


await Event.toPromise(Event.once(this._taskService.onDidChangeTaskSystemInfo)); } <del> this._logService.trace('RunAutomaticTasks: Checking if automatic tasks should run.'); const isFolderAutomaticAllowed = this._configurationService.getValue(ALLOW_AUTOMATIC_TASKS) !== 'off'; await this._workspaceTrustManagementService.workspaceTrustInitialized; const isWorkspaceTrusted = this._workspaceTrustManagementService.isWorkspaceTrusted(); // Only run if allowed. Prompting for permission occurs when a user first tries to run a task. if (isFolderAutomaticAllowed && isWorkspaceTrusted) { this._taskService.getWorkspaceTasks(TaskRunSource.FolderOpen).then(workspaceTaskResult => { const { tasks } = RunAutomaticTasks._findAutoTasks(this._taskService, workspaceTaskResult); this._logService.trace(`RunAutomaticTasks: Found ${tasks.length} automatic tasks tasks`); if (tasks.length > 0) { RunAutomaticTasks._runTasks(this._taskService, tasks); } }); } </del> <ins> const workspaceTasks = await this._taskService.getWorkspaceTasks(TaskRunSource.FolderOpen); this._logService.trace(`RunAutomaticTasks: Found ${workspaceTasks.size} automatic tasks`); await RunAutomaticTasks.runWithPermission(this._taskService, this._storageService, this._notificationService, this._workspaceTrustManagementService, this._openerService, this._configurationService, workspaceTasks); </ins> } private static _runTasks(taskService: ITaskService, tasks: Array<Task | Promise<Task | undefined>>) {


import { CommandsRegistry } from 'vs/platform/commands/common/commands'; import { ContextKeyExpr, ContextKeyExpression, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; import { defaultKeybindingLabelStyles } from 'vs/platform/theme/browser/defaultStyles'; <ins> import { editorForeground, registerColor, transparent } from 'vs/platform/theme/common/colorRegistry'; registerColor('editorWatermark.foreground', { dark: transparent(editorForeground, 0.6), light: transparent(editorForeground, 0.68), hcDark: editorForeground, hcLight: editorForeground }, localize('editorLineHighlight', 'Foreground color for the labels in the editor watermark.')); </ins> interface WatermarkEntry { readonly text: string;


</dict> </array> <key>while</key> <del> <string>(^|G)(?!s*$|#|[ ]{0,3}([-*_][ ]{2,}){3,}[ t]*$n?|>|[ ]{0,3}[*+-]|[ ]{0,3}[0-9]+.)</string> </del> <ins> <string>(^|G)(?!s*$|#|[ ]{0,3}([-*_>][ ]{2,}){3,}[ t]*$n?|[ ]{0,3}[*+->]|[ ]{0,3}[0-9]+.)</string> </ins> </dict> <key>lists</key> <dict>


@ITextModelService private readonly textModelService: ITextModelService, @IBulkEditService private readonly bulkEditService: IBulkEditService, @IConfigurationService private readonly configurationService: IConfigurationService, <del> ) { } </del> <ins> ) { } </ins> async participate(workingCopy: IStoredFileWorkingCopy<IStoredFileWorkingCopyModel>, context: { reason: SaveReason }, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void> { if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {


import { ILogService } from 'vs/platform/log/common/log'; import { Workspace } from 'vs/platform/workspace/common/workspace'; import { URI } from 'vs/base/common/uri'; <del> import { checkProposedApiEnabled } from 'vs/workbench/services/extensions/common/extensions'; </del> function lookUp(tree: any, key: string) { if (key) {


}, 'terminal.integrated.enableBold': { 'type': 'boolean', <del> 'description': nls.localize('terminal.integrated.enableBold', "Whether to enable bold text within the terminal."), </del> <ins> 'description': nls.localize('terminal.integrated.enableBold', "Whether to enable bold text within the terminal, this requires support from the termianl shell."), </ins> 'default': true }, 'terminal.integrated.cursorBlinking': {


/** * The declaration of a symbol representation as one or many [locations](#Location) <del> * or [location links][#LocationLink]. </del> <ins> * or [location links](#LocationLink). </ins> */ export type Declaration = Location | Location[] | LocationLink[];


lineHeight = fontInfo.lineHeight; } else if (lineHeight < minimumLineHeight) { // Values too small to be line heights in pixels are in ems. <del> let fontSize = this.configurationService.getValue<number>(NotebookSetting.outputFontSize); </del> <ins> let fontSize = outputFontSize; </ins> if (fontSize === 0) { fontSize = this.configurationService.getValue<number>('editor.fontSize'); }


// Set the new shell launch config this._shellLaunchConfig = shell; // Must be done before calling _createProcess() <del> this._processManager.relaunch(this._shellLaunchConfig, this._cols || Constants.DefaultCols, this._rows || Constants.DefaultRows, this._accessibilityService.isScreenReaderOptimized(), reset); </del> <ins> await this._processManager.relaunch(this._shellLaunchConfig, this._cols || Constants.DefaultCols, this._rows || Constants.DefaultRows, this._accessibilityService.isScreenReaderOptimized(), reset).then(error => { if (error) { this._onProcessExit(error); } }); </ins> this._xtermTypeAheadAddon?.reset(); }


} private handleExtensionData(extensions: IssueReporterExtensionData[]) { <del> const { nonThemes, themes } = collections.groupBy(extensions, ext => { </del> <ins> const installedExtensions = extensions.filter(x => !x.isBuiltin); const { nonThemes, themes } = collections.groupBy(installedExtensions, ext => { </ins> return ext.isTheme ? 'themes' : 'nonThemes'; }); const numberOfThemeExtesions = themes && themes.length; <del> this.issueReporterModel.update({ numberOfThemeExtesions, enabledNonThemeExtesions: nonThemes, allExtensions: extensions }); </del> <ins> this.issueReporterModel.update({ numberOfThemeExtesions, enabledNonThemeExtesions: nonThemes, allExtensions: installedExtensions }); </ins> this.updateExtensionTable(nonThemes, numberOfThemeExtesions); <del> if (this.environmentService.disableExtensions || extensions.length === 0) { </del> <ins> if (this.environmentService.disableExtensions || installedExtensions.length === 0) { </ins> (<HTMLButtonElement>this.getElementById('disableExtensions')).disabled = true; } <del> this.updateExtensionSelector(extensions); </del> <ins> this.updateExtensionSelector(installedExtensions); </ins> } private handleSettingsSearchData(data: ISettingsSearchIssueReporterData): void {


action: (!this.isQuickNavigate() && currentWindowId !== win.id) ? this.closeWindowAction : void 0 } as IFilePickOpenEntry)); <ins> const autoFocusIndex = (picks.indexOf(picks.filter(pick => pick.payload === currentWindowId)[0]) + 1) % picks.length; </ins> this.quickOpenService.pick(picks, { contextKey: 'inWindowsPicker', <del> autoFocus: { autoFocusFirstEntry: true }, </del> <ins> autoFocus: { autoFocusIndex }, </ins> placeHolder, quickNavigateConfiguration: this.isQuickNavigate() ? { keybindings: this.keybindingService.lookupKeybindings(this.id) } : void 0 });


'For instructions, see http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx.</value>', '                      http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx         ' ); <ins> assertLink( 'x = "https://en.wikipedia.org/wiki/Zürich";', '     https://en.wikipedia.org/wiki/Zürich  ' ); assertLink( '請參閱 http://go.microsoft.com/fwlink/?LinkId=761051。', '    http://go.microsoft.com/fwlink/?LinkId=761051 ' ); assertLink( '（請參閱 http://go.microsoft.com/fwlink/?LinkId=761051）', '     http://go.microsoft.com/fwlink/?LinkId=761051 ' ); </ins> // foo bar (see http://www.w3schools.com/tags/att_iframe_sandbox.asp) });


"badge.background": "#705697AA", "progressBar.background": "#705697" } <del> } </del>  No newline at end of file <ins> } </ins>


class HitTestRequest extends BareHitTestRequest { private readonly _ctx: HitTestContext; <del> public readonly target: HTMLElement | null; public readonly targetPath: Uint8Array; </del> <ins> private readonly _eventTarget: HTMLElement | null; public readonly hitTestResult = new Lazy(() => MouseTargetFactory.doHitTest(this._ctx, this)); private _useHitTestTarget: boolean; private _targetPathCacheElement: HTMLElement | null = null; private _targetPathCacheValue: Uint8Array = new Uint8Array(0); public get target(): HTMLElement | null { if (this._useHitTestTarget) { return this.hitTestResult.value.hitTarget; } return this._eventTarget; } </ins> <del> constructor(ctx: HitTestContext, editorPos: EditorPagePosition, pos: PageCoordinates, relativePos: CoordinatesRelativeToEditor, target: HTMLElement | null) { </del> <ins> public get targetPath(): Uint8Array { if (this._targetPathCacheElement !== this.target) { this._targetPathCacheElement = this.target; this._targetPathCacheValue = PartFingerprints.collect(this.target, this._ctx.viewDomNode); } return this._targetPathCacheValue; } constructor(ctx: HitTestContext, editorPos: EditorPagePosition, pos: PageCoordinates, relativePos: CoordinatesRelativeToEditor, eventTarget: HTMLElement | null) { </ins> super(ctx, editorPos, pos, relativePos); this._ctx = ctx; <ins> this._eventTarget = eventTarget; </ins> <del> if (target) { this.target = target; this.targetPath = PartFingerprints.collect(target, ctx.viewDomNode); } else { this.target = null; this.targetPath = new Uint8Array(0); } </del> <ins> // If no event target is passed in, we will use the hit test target const hasEventTarget = Boolean(this._eventTarget); this._useHitTestTarget = !hasEventTarget; </ins> } public override toString(): string { return `pos(${this.pos.x},${this.pos.y}), editorPos(${this.editorPos.x},${this.editorPos.y}), relativePos(${this.relativePos.x},${this.relativePos.y}), mouseVerticalOffset: ${this.mouseVerticalOffset}, mouseContentHorizontalOffset: ${this.mouseContentHorizontalOffset}nttarget: ${this.target ? (<HTMLElement>this.target).outerHTML : null}`; } <ins> public get wouldBenefitFromHitTestTargetSwitch(): boolean { return ( !this._useHitTestTarget && this.hitTestResult.value.hitTarget !== null && this.target !== this.hitTestResult.value.hitTarget ); } public switchToHitTestTarget(): void { this._useHitTestTarget = true; } </ins> private _getMouseColumn(position: Position | null = null): number { if (position && position.column < this._ctx.viewModel.getLineMaxColumn(position.lineNumber)) { // Most likely, the line contains foreign decorations...


*--------------------------------------------------------------------------------------------*/ import { KeyCode, KeyMod } from 'vs/base/common/keyCodes'; <del> import { Disposable, DisposableStore } from 'vs/base/common/lifecycle'; </del> <ins> import { Disposable, DisposableStore, IDisposable, MutableDisposable } from 'vs/base/common/lifecycle'; </ins> import { localize } from 'vs/nls'; import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from 'vs/platform/accessibility/common/accessibility'; import { Action2, registerAction2 } from 'vs/platform/actions/common/actions';


const baseConfig: IOpenConfiguration = { context, cli: args, <del> userEnv, </del> <ins> /** * When opening a new window from a second instance that sent args and env * over to this instance, we want to preserve the environment only if that second * instance was spawned from the CLI or used the `--preserve-env` flag (example: * when using `open -n "VSCode.app" --args --preserve-env WORKSPACE_FOLDER`). * * This is done to ensure that the second window gets treated exactly the same * as the first window, for example, it gets the same resolved user shell environment. * * https://github.com/microsoft/vscode/issues/194736 */ userEnv: (args['preserve-env'] || context === OpenContext.CLI) ? userEnv : undefined, </ins> waitMarkerFileURI, remoteAuthority, forceProfile: args.profile,


async setLocale(languagePackItem: ILanguagePackItem, _skipDialog = false): Promise<void> { const locale = languagePackItem.id; <del> if (locale === Language.value() || (!locale && Language.value() === navigator.language)) { </del> <ins> if (locale === Language.value() || (!locale && Language.value() === navigator.language.toLowerCase())) { </ins> return; } if (locale) {


const groupActiveEditorAvailableEditorIds = this.editorPartsView.bind(ActiveEditorAvailableEditorIdsContext, this); const groupActiveEditorCanSplitInGroupContext = this.editorPartsView.bind(ActiveEditorCanSplitInGroupContext, this); <del> const sideBySideEditorContext = this.editorPartsView.bind(SideBySideEditorActiveContext, this); </del> <ins> const groupActiveEditorIsSideBySideEditorContext = this.editorPartsView.bind(SideBySideEditorActiveContext, this); </ins> const activeEditorListener = this._register(new MutableDisposable());


[UninstallDelete] Type: filesandordirs; Name: "{app}_" <del> Type: filesandordirs; Name: "{app}old" </del> [Tasks] Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked


import { IColorTheme } from '../../../platform/theme/common/themeService.js'; import { CompositeBar, ICompositeBarItem, CompositeDragAndDrop } from './compositeBar.js'; import { Dimension, createCSSRule, asCSSUrl, isMouseEvent } from '../../../base/browser/dom.js'; <del> import { IStorageService, StorageScope, StorageTarget, IProfileStorageValueChangeEvent } from '../../../platform/storage/common/storage.js'; </del> <ins> import { IStorageService, StorageScope, StorageTarget } from '../../../platform/storage/common/storage.js'; </ins> import { IExtensionService } from '../../services/extensions/common/extensions.js'; import { URI, UriComponents } from '../../../base/common/uri.js'; import { ToggleCompositePinnedAction, ICompositeBarColors, IActivityHoverOptions, ToggleCompositeBadgeAction, CompositeBarAction, ICompositeBar, ICompositeBarActionItem } from './compositeBarActions.js';


return; } this.onDidRegisterExtensions(); <del> this._register(this.compositeBar.onDidChange(() => this.saveCachedViewContainers())); this._register(this.storageService.onDidChangeValue(StorageScope.PROFILE, this.options.pinnedViewContainersKey, this._store)(e => this.onDidPinnedViewContainersStorageValueChange(e))); </del> <ins> this._register(this.compositeBar.onDidChange(() => { this.updateCompositeBarItemsFromStorage(true); this.saveCachedViewContainers(); })); this._register(this.storageService.onDidChangeValue(StorageScope.PROFILE, this.options.pinnedViewContainersKey, this._store)(() => this.updateCompositeBarItemsFromStorage(false))); </ins> }); }


<ins> { "displayName": "Dart Language Basics", "description": "Provides syntax highlighting & bracket matching in Dart files." } </ins>


}, product: { nameShort: product.nameShort, <del> version: product.version, </del> <ins> version: !!product.darwinUniversalAssetId ? `${product.version} (Universal)` : product.version, </ins> commit: product.commit, date: product.date, reportIssueUrl: product.reportIssueUrl


this.onDidExitOrCrashOrKill(); })); <ins> // V8 Error this._register(Event.fromNodeEventEmitter(process, 'error', (type, location, report) => ({ type, location, report }))(({ type, location, report }) => { this.log(`crashed due to ${type} from V8 at ${location}`, Severity.Info); let addons: string[] = []; try { const reportJSON = JSON.parse(report); addons = reportJSON.sharedObjects .filter((sharedObject: string) => sharedObject.endsWith('.node')) .map((addon: string) => { const index = addon.indexOf('extensions') === -1 ? addon.indexOf('node_modules') : addon.indexOf('extensions'); return addon.substring(index); }); } catch (e) { // ignore } // Telemetry type UtilityProcessV8ErrorClassification = { processtype: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'The type of utility process to understand the origin of the crash better.' }; error: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'The type of error from the utility process to understand the nature of the crash better.' }; location: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'The source location that triggered the crash to understand the nature of the crash better.' }; addons: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'The list of addons loaded in the utility process to understand the nature of the crash better' }; owner: 'deepak1556'; comment: 'Provides insight into V8 sandbox FATAL error caused by native addons.'; }; type UtilityProcessV8ErrorEvent = { processtype: string; error: string; location: string; addons: string[]; }; this.telemetryService.publicLog2<UtilityProcessV8ErrorEvent, UtilityProcessV8ErrorClassification>('utilityprocessv8error', { processtype: configuration.type, error: type, location, addons }); })); </ins> // Child process gone this._register(Event.fromNodeEventEmitter<{ details: Details }>(app, 'child-process-gone', (event, details) => ({ event, details }))(({ details }) => { if (details.type === 'Utility' && details.name === serviceName && !this.isNormalExit(details.exitCode)) {


"config.rebaseWhenSync": "Force git to use rebase when running the sync command.", "config.confirmEmptyCommits": "Always confirm the creation of empty commits for the 'Git: Commit Empty' command.", "config.fetchOnPull": "When enabled, fetch all branches when pulling. Otherwise, fetch just the current one.", <del> "config.fetchBeforeCheckout": "Controls whether a branch that does not have outgoing commits is fast-forwarded before it is checked out.", </del> <ins> "config.pullBeforeCheckout": "Controls whether a branch that does not have outgoing commits is fast-forwarded before it is checked out.", </ins> "config.pullTags": "Fetch all tags when pulling.", "config.pruneOnFetch": "Prune when fetching.", "config.autoStash": "Stash any changes before pulling and restore them after successful pull.",


model.setLanguage(provider.options.language); } container.appendChild(this._editorContainer); <del> this._keyListener = this._register(this._editorWidget.onKeyUp((e) => { if (e.keyCode === KeyCode.Escape) { this._contextViewService.hideContextView(); // Delay to allow the context view to hide #186514 setTimeout(() => provider.onClose(), 100); this._keyListener?.dispose(); } else if (e.keyCode === KeyCode.KeyD && this._configurationService.getValue(settingKey)) { this._configurationService.updateValue(settingKey, false); } else if (e.keyCode === KeyCode.KeyH && provider.options.readMoreUrl) { const url: string = provider.options.readMoreUrl!; alert(AccessibilityHelpNLS.openingDocs); this._openerService.open(URI.parse(url)); } e.stopPropagation(); provider.onKeyDown?.(e); })); this._register(this._editorWidget.onDidBlurEditorText(() => this._contextViewService.hideContextView())); this._register(this._editorWidget.onDidContentSizeChange(() => this._layout())); </del> this._editorWidget.updateOptions({ ariaLabel: provider.options.ariaLabel }); this._editorWidget.focus(); }); <del> return toDisposable(() => { }); </del> <ins> const disposableStore = new DisposableStore(); disposableStore.add(this._editorWidget.onKeyUp((e) => { if (e.keyCode === KeyCode.Escape) { this._contextViewService.hideContextView(); // Delay to allow the context view to hide #186514 setTimeout(() => provider.onClose(), 100); } else if (e.keyCode === KeyCode.KeyD && this._configurationService.getValue(settingKey)) { this._configurationService.updateValue(settingKey, false); } e.stopPropagation(); provider.onKeyDown?.(e); })); disposableStore.add(this._editorWidget.onKeyDown((e) => { if (e.keyCode === KeyCode.KeyH && provider.options.readMoreUrl) { const url: string = provider.options.readMoreUrl!; alert(AccessibilityHelpNLS.openingDocs); this._openerService.open(URI.parse(url)); e.preventDefault(); e.stopPropagation(); } })); disposableStore.add(this._editorWidget.onDidBlurEditorText(() => this._contextViewService.hideContextView())); disposableStore.add(this._editorWidget.onDidContentSizeChange(() => this._layout())); return disposableStore; </ins> } private _layout(): void {


constructor( private readonly editor: ICodeEditor, @ISpeechService private readonly speechService: ISpeechService, <del> @IContextKeyService private readonly contextKeyService: IContextKeyService </del> <ins> @IContextKeyService private readonly contextKeyService: IContextKeyService, @IKeybindingService private readonly keybindingService: IKeybindingService </ins> ) { super(); }


if (settingId !== this.currentProductIconTheme.settingsId) { await this.internalSetProductIconTheme(theme.id, undefined); } else if (theme !== this.currentProductIconTheme) { <ins> await theme.ensureLoaded(this.extensionResourceLoaderService, this.logService); </ins> this.applyAndSetProductIconTheme(theme, true); } return true;


return await handler.handleURL(uri, options); } <del> private async handleUnhandledURL(uri: URI, extensionIdentifier: IExtensionIdentifier): Promise<void> { </del> <ins> private async handleUnhandledURL(uri: URI, extensionIdentifier: IExtensionIdentifier, options?: IOpenURLOptions): Promise<void> { </ins> const installedExtensions = await this.extensionManagementService.getInstalled(); <del> const extension = installedExtensions.filter(e => areSameExtensions(e.identifier, extensionIdentifier))[0]; // Extension is installed if (extension) { const enabled = this.extensionEnablementService.isEnabled(extension); // Extension is not running. Reload the window to handle. if (enabled) { this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/activate_extension/start', { extensionId: extensionIdentifier.id }); const result = await this.dialogService.confirm({ message: localize('reloadAndHandle', "Extension '{0}' is not loaded. Would you like to reload the window to load the extension and open the URL?", extension.manifest.displayName || extension.manifest.name), detail: `${extension.manifest.displayName || extension.manifest.name} (${extensionIdentifier.id}) wants to open a URL:nn${uri.toString()}`, primaryButton: localize('reloadAndOpen', "&&Reload Window and Open"), type: 'question' }); if (!result.confirmed) { this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/activate_extension/cancel', { extensionId: extensionIdentifier.id }); return; } this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/activate_extension/accept', { extensionId: extensionIdentifier.id }); await this.reloadAndHandle(uri); } // Extension is disabled. Enable the extension and reload the window to handle. else if (this.extensionEnablementService.canChangeEnablement(extension)) { this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/enable_extension/start', { extensionId: extensionIdentifier.id }); const result = await this.dialogService.confirm({ message: localize('enableAndHandle', "Extension '{0}' is disabled. Would you like to enable the extension and reload the window to open the URL?", extension.manifest.displayName || extension.manifest.name), detail: `${extension.manifest.displayName || extension.manifest.name} (${extensionIdentifier.id}) wants to open a URL:nn${uri.toString()}`, primaryButton: localize('enableAndReload', "&&Enable and Open"), type: 'question' }); if (!result.confirmed) { this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/enable_extension/cancel', { extensionId: extensionIdentifier.id }); return; } this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/enable_extension/accept', { extensionId: extensionIdentifier.id }); await this.extensionEnablementService.setEnablement([extension], EnablementState.EnabledGlobally); await this.reloadAndHandle(uri); } } </del> <ins> let extension = installedExtensions.find(e => areSameExtensions(e.identifier, extensionIdentifier)); </ins> // Extension is not installed <del> else { </del> <ins> if (!extension) { </ins> let galleryExtension: IGalleryExtension | undefined; try {


window.onload = () => { if (window.initialData.scrollPreviewWithEditorSelection) { <del> const initialLine = +window.initialData.line || 0; setTimeout(() => { scrollDisabled = true; scrollToRevealSourceLine(initialLine); }, 0); </del> <ins> const initialLine = +window.initialData.line; if (!isNaN(initialLine)) { setTimeout(() => { scrollDisabled = true; scrollToRevealSourceLine(initialLine); }, 0); } </ins> } };


<meta http-equiv="Content-Security-Policy" content=" default-src 'none'; <del> font-src ${this._webviewPanel.webview.cspSource}; </del> <ins> font-src data:; </ins> style-src ${this._webviewPanel.webview.cspSource}; script-src 'nonce-${nonce}'; frame-src *;


readonly type: string; readonly entrypoint: URI; readonly extensionLocation: URI; <ins> readonly localResourceRoots: readonly URI[]; </ins> } export interface IOrderedMimeType {


alert(localize('disableAccessibilityHelp', '{0} accessibility verbosity is now disabled', this._currentProvider.verbositySettingKey)); } <del> private _render(provider: IAccessibleContentProvider, container: HTMLElement): IDisposable { this._currentProvider = provider; </del> <ins> private _render(provider: IAccessibleContentProvider, container: HTMLElement, internal?: boolean): IDisposable { if (!internal) { this._currentProvider = provider; } </ins> const value = this._configurationService.getValue(provider.verbositySettingKey); const readMoreLink = provider.options.readMoreUrl ? localize("openDoc", "nPress H now to open a browser window with more information related to accessibility.n") : ''; <del> const disableHintKb = this._keybindingService.lookupKeybinding('editor.action.accessibleViewDisableHint')?.getAriaLabel(); let disableHelpHint; </del> <ins> let disableHelpHint = ''; </ins> if (provider.options.type === AccessibleViewType.Help && !!value) { <del> if (disableHintKb) { disableHelpHint = localize('disable-help-hint', 'nTo disable the `accessibility.verbosity` hint for this feature, press {0} now.n', disableHintKb); } else { disableHelpHint = localize('disable-help-hint-no-b', 'nTo disable the `accessibility.verbosity` hint for this feature, assign a keybinding to the Disable Accessible View Hint command, which is currently not triggerable via keybinding.n'); } } else { disableHelpHint = 'n'; </del> <ins> disableHelpHint = this._getDisableVerbosityHint(provider.verbositySettingKey); </ins> } const accessibilitySupport = this._accessibilityService.isScreenReaderOptimized(); let message = '';


menu: { id: MenuId.ChatCodeBlock, group: 'navigation', <del> } </del> <ins> }, keybinding: { when: CONTEXT_ACCESSIBILITY_MODE_ENABLED, primary: KeyMod.CtrlCmd | KeyCode.Enter, mac: { primary: KeyMod.WinCtrl | KeyCode.Enter }, weight: KeybindingWeight.WorkbenchContrib }, </ins> }); }


<ins> { "name": "dart", "displayName": "%displayName%", "description": "%description%", "version": "1.0.0", "publisher": "vscode", "license": "MIT", "engines": { "vscode": "0.10.x" }, "scripts": { "update-grammar": "node ../node_modules/vscode-grammar-updater/bin dart-lang/dart-syntax-highlight grammars/dart.json ./syntaxes/dart.tmLanguage.json" }, "contributes": { "languages": [ { "id": "dart", "extensions": [ ".dart" ], "aliases": [ "Dart" ], "configuration": "./syntaxes/dart-language-configuration.json" } ], "grammars": [ { "language": "dart", "scopeName": "source.dart", "path": "./syntaxes/dart.tmLanguage.json" } ] } } </ins>


}, getRole: options.ariaProvider!.getRole ? (el) => { return options.ariaProvider!.getRole!(el.element as T); <del> } : undefined, </del> <ins> } : () => 'treeitem', </ins> isChecked: options.ariaProvider!.isChecked ? (e) => { return options.ariaProvider?.isChecked!(e.element as T); } : undefined


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


import { getSimpleEditorOptions } from 'vs/workbench/contrib/codeEditor/browser/simpleEditorOptions'; const enum DIMENSION_DEFAULT { <del> WIDTH = .6, HEIGHT = 200 </del> <ins> WIDTH = 800 </ins> } export interface IAccessibleContentProvider {


// Set up nls if the user is not using the default language (English) const nlsConfig = {}; <del> const locale = window.localStorage.getItem('vscode.nls.locale') || navigator.language; </del> <ins> // Normalize locale to lowercase because translationServiceUrl is case-sensitive. // ref: https://github.com/microsoft/vscode/issues/187795 const locale = window.localStorage.getItem('vscode.nls.locale') || navigator.language.toLowerCase(); </ins> if (!locale.startsWith('en')) { nlsConfig['vs/nls'] = { availableLanguages: {


import { DEFAULT_EDITOR_ASSOCIATION } from 'vs/workbench/common/editor'; import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry'; import { KeyCode, KeyMod } from 'vs/base/common/keyCodes'; <del> import { CellEditType, NOTEBOOK_DIFF_EDITOR_ID } from 'vs/workbench/contrib/notebook/common/notebookCommon'; </del> <ins> import { CellEditType, ICellEditOperation, NOTEBOOK_DIFF_EDITOR_ID } from 'vs/workbench/contrib/notebook/common/notebookCommon'; </ins> import { ITextResourceConfigurationService } from 'vs/editor/common/services/textResourceConfiguration'; import { NotebookMultiTextDiffEditor } from 'vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditor'; import { Codicon } from 'vs/base/common/codicons';


if (styles.backgroundColor) { content.push(`.monaco-workbench { background-color: ${styles.backgroundColor} !important; }`); <ins> content.push(`.issue-reporter-body::-webkit-scrollbar-track { background-color: ${styles.backgroundColor}; }`); </ins> } if (styles.inputBorder) {


} const decorations = this._context.viewModel.getAllOverviewRulerDecorations(this._context.theme); <del> decorations.sort(OverviewRulerDecorationsGroup.cmp); </del> <ins> decorations.sort(OverviewRulerDecorationsGroup.compareByRenderingProps); </ins> if (this._actualShouldRender === ShouldRenderValue.Maybe && !OverviewRulerDecorationsGroup.equalsArr(this._renderedDecorations, decorations)) { this._actualShouldRender = ShouldRenderValue.Needed;


await this._init(); <del> let treatments = this.treatment?.extensions.filter(extension => !this.ignoredExtensions.has(extension)) ?? new Array<string>(); </del> <ins> let treatments = this.treatment?.extensions?.filter(extension => !this.ignoredExtensions.has(extension)) ?? new Array<string>(); </ins> const featuredExtensions: IFeaturedExtension[] = new Array(); if (this.treatment?.showAsList !== 'true' && treatments.length > 0) {


addRecentlyOpened(recents: IRecent[]): Promise<void>; getRecentlyOpened(): Promise<IRecentlyOpened>; removeRecentlyOpened(paths: URI[]): Promise<void>; <del> clearRecentlyOpened(): Promise<void>; </del> <ins> clearRecentlyOpened(options?: { confirm?: boolean }): Promise<void>; </ins> } export class WorkspacesHistoryMainService extends Disposable implements IWorkspacesHistoryMainService {


} async getRefs(query: RefQuery = {}, cancellationToken?: CancellationToken): Promise<Ref[]> { <del> return await this.run(Operation.GetRefs, () => { return this.repository.getRefs(query, cancellationToken); }); </del> <ins> const config = workspace.getConfiguration('git'); let defaultSort = config.get<'alphabetically' | 'committerdate'>('branchSortOrder'); if (defaultSort !== 'alphabetically' && defaultSort !== 'committerdate') { defaultSort = 'alphabetically'; } query = { ...query, sort: query?.sort ?? defaultSort }; return await this.run(Operation.GetRefs, () => this.repository.getRefs(query, cancellationToken)); </ins> } async getRemoteRefs(remote: string, opts?: { heads?: boolean; tags?: boolean }): Promise<Ref[]> {


if (instance.shellLaunchConfig.ignoreShellIntegration) { shellIntegrationString += `${markdown ? 'nn---nn' : 'nn'} ${localize('launchFailed.exitCodeOnlyShellIntegration', "The terminal process failed to launch. Disabling shell integration with terminal.integrated.shellIntegration.enabled might help.")}`; } else { <del> shellIntegrationString += `${markdown ? 'nn---nn' : 'nn'} ${localize('shellIntegration.activationFailed', "Shell integration failed to activate")}`; </del> <ins> if (instance.usedShellIntegrationInjection) { shellIntegrationString += `${markdown ? 'nn---nn' : 'nn'} ${localize('shellIntegration.activationFailed', "Shell integration failed to activate")}`; } </ins> } } return shellIntegrationString;


test('Aggressive inline completions when typing within line #146948', async function () { <del> const completions: SuggestInlineCompletions = insta.createInstance(SuggestInlineCompletions); </del> <ins> const completions: SuggestInlineCompletions = disposables.add(insta.createInstance(SuggestInlineCompletions)); </ins> { // (1,3), end of word -> suggestions


key: 'workbench.editor.untitled.hint', migrateFn: (value, _accessor) => ([ [emptyTextEditorHintSetting, { value }], <ins> ['workbench.editor.untitled.hint', { value: undefined }] </ins> ]) }, { key: 'accessibility.verbosity.untitledHint', migrateFn: (value, _accessor) => ([ [AccessibilityVerbositySettingId.EmptyEditorHint, { value }], <ins> ['accessibility.verbosity.untitledHint', { value: undefined }] </ins> ]) }]);


@IThemeService private readonly _themeService: IThemeService, @IConfigurationService private readonly _configurationService: IConfigurationService ) { <del> super({ showCommonFindToggles: true, checkImeCompletionState: true, showResultCount: true, type: 'Terminal', matchesLimit: XtermTerminalConstants.SearchHighlightLimit }, _contextViewService, _contextKeyService, keybindingService); </del> <ins> super({ showCommonFindToggles: true, checkImeCompletionState: true, showResultCount: true, appendCaseSensitiveActionId: TerminalCommandId.ToggleFindCaseSensitive, appendRegexActionId: TerminalCommandId.ToggleFindRegex, appendWholeWordsActionId: TerminalCommandId.ToggleFindWholeWord, previousMatchActionId: TerminalCommandId.FindPrevious, nextMatchActionId: TerminalCommandId.FindNext, closeWidgetActionId: TerminalCommandId.FindHide, type: 'Terminal', matchesLimit: XtermTerminalConstants.SearchHighlightLimit }, _contextViewService, _contextKeyService, keybindingService); </ins> this._register(this.state.onFindReplaceStateChange(() => { this.show();


.action-widget .monaco-list-row.action.option-disabled, .action-widget .monaco-list:focus .monaco-list-row.focused.action.option-disabled, <del> .action-widget .monaco-list-row.action.option-disabled .codicon { </del> <ins> .action-widget .monaco-list-row.action.option-disabled .codicon, .action-widget .monaco-list:not(.drop-target):not(.dragging) .monaco-list-row:hover:not(.selected):not(.focused).option-disabled { </ins> color: var(--vscode-disabledForeground); }


} else if (name === 'nu') { // nushell requires ^ before quoted path to treat it as a command command = `^'${process.execPath}' ${extraArgs} -p '"${mark}" + JSON.stringify(process.env) + "${mark}"'`; shellArgs = ['-i', '-l', '-c']; <ins> } else if (name === 'xonsh') { // #200374: native implementation is shorter command = `import os, json; print("${mark}", json.dumps(dict(os.environ)), "${mark}")`; shellArgs = ['-i', '-l', '-c']; </ins> } else { command = `'${process.execPath}' ${extraArgs} -p '"${mark}" + JSON.stringify(process.env) + "${mark}"'`;


showMethods: boolean(input.showMethods, this.defaultValue.showMethods), showFunctions: boolean(input.showFunctions, this.defaultValue.showFunctions), showConstructors: boolean(input.showConstructors, this.defaultValue.showConstructors), <ins> showDeprecated: boolean(input.showDeprecated, this.defaultValue.showDeprecated), </ins> showFields: boolean(input.showFields, this.defaultValue.showFields), showVariables: boolean(input.showVariables, this.defaultValue.showVariables), showClasses: boolean(input.showClasses, this.defaultValue.showClasses),


import { CompletionItem, getSuggestionComparator, SnippetSortOrder } from 'vs/editor/contrib/suggest/browser/suggest'; import { WordDistance } from 'vs/editor/contrib/suggest/browser/wordDistance'; <del> export function createSuggestItem(label: string, overwriteBefore: number, kind = languages.CompletionItemKind.Property, incomplete: boolean = false, position: IPosition = { lineNumber: 1, column: 1 }, sortText?: string, filterText?: string): CompletionItem { </del> <ins> export function createSuggestItem(label: string | languages.CompletionItemLabel, overwriteBefore: number, kind = languages.CompletionItemKind.Property, incomplete: boolean = false, position: IPosition = { lineNumber: 1, column: 1 }, sortText?: string, filterText?: string): CompletionItem { </ins> const suggestion: languages.CompletionItem = { label, sortText, filterText, range: { startLineNumber: position.lineNumber, startColumn: position.column - overwriteBefore, endLineNumber: position.lineNumber, endColumn: position.column }, <del> insertText: label, </del> <ins> insertText: typeof label === 'string' ? label : label.label, </ins> kind }; const container: languages.CompletionList = {


} } <del> updateOptions(e: NotebookOptionsChangeEvent) { </del> <ins> override updateOptions(e: NotebookOptionsChangeEvent) { super.updateOptions(e); </ins> if (e.cellStatusBarVisibility || e.insertToolbarPosition || e.cellToolbarLocation) { this.layoutChange({}); }


<ins> { "comments": { "lineComment": "//", "blockComment": [ "/*", "*/" ] }, "brackets": [ ["{", "}"], ["[", "]"], ["(", ")"] ], "autoClosingPairs": [ { "open": "{", "close": "}" }, { "open": "[", "close": "]" }, { "open": "(", "close": ")" }, { "open": "'", "close": "'", "notIn": ["string", "comment"] }, { "open": """, "close": """, "notIn": ["string"] }, { "open": "`", "close": "`", "notIn": ["string", "comment"] }, { "open": "/**", "close": " */", "notIn": ["string"] } ], "surroundingPairs": [ ["{", "}"], ["[", "]"], ["(", ")"], ["<", ">"], ["'", "'"], [""", """], ["`", "`"] ] } </ins>


cachedViewContainer = cachedViewContainer || this.cachedViewContainers.find(({ id }) => id === viewContainerId); // Show builtin ViewContainer if not registered yet <del> if (!viewContainer && cachedViewContainer?.isBuiltin) { </del> <ins> if (!viewContainer && cachedViewContainer?.isBuiltin && cachedViewContainer?.visible) { </ins> return false; }


} } quickPick.selectedItems = selectedItems; <del> quickPick.onDidChangeSelection(async e => { </del> <ins> this._register(quickPick.onDidChangeSelection(async e => { </ins> let newValue: 'both' | 'gutter' | 'overviewRuler' | 'never' = 'never'; if (e.includes(gutterIcon)) { if (e.includes(overviewRulerIcon)) {


icon: new ThemeIcon('target') }); break; <del> case ref.startsWith('tag: refs/tags/'): references.push({ id: ref.substring('tag: '.length), name: ref.substring('tag: refs/tags/'.length), revision: commit.hash, icon: new ThemeIcon('tag') }); break; </del> case ref.startsWith('refs/heads/'): references.push({ id: ref,


os: `${os.type()} ${os.arch()} ${os.release()}${isSnap ? ' snap' : ''}` }, extensionsDisabled: !!this.environmentService.disableExtensions, <del> fileOnExtension: configuration.data.extensionId ? true : undefined, selectedExtension: configuration.data.extensionId ? configuration.data.enabledExtensions.filter(extension => extension.id === configuration.data.extensionId)[0] : undefined </del> <ins> fileOnExtension: configuration.data.extensionId ? !targetExtension?.isBuiltin : undefined, selectedExtension: targetExtension, </ins> }); const issueReporterElement = this.getElementById('issue-reporter');


if (model) { this._bufferEditor.setModel(model); } <ins> this._bufferEditor.onDidFocusEditorText(() => this._accessibleBuffer.classList.add('active')); </ins> if (!this._registered) { this._bufferEditor.layout({ width: this._xtermElement.clientWidth, height: this._xtermElement.clientHeight }); this._bufferEditor.onKeyDown((e) => { <ins> // tab moves focus mode will prematurely move focus to the next element before // xterm can be focused </ins> if (e.keyCode === KeyCode.Escape || e.keyCode === KeyCode.Tab) { <ins> e.stopPropagation(); e.preventDefault(); </ins> this._hide(); } });


"license": "MIT", "description": "Dependencies shared by all extensions", "dependencies": { <del> "typescript": "5.4.3" </del> <ins> "typescript": "5.4.4" </ins> }, "scripts": { "postinstall": "node ./postinstall.mjs"


} } <del> input(data: string, isBinary?: boolean): void { </del> <ins> input(data: string, isBinary: boolean = false): void { </ins> if (this._store.isDisposed || !this._ptyProcess) { return; } <del> for (let i = 0; i <= Math.floor(data.length / Constants.WriteMaxChunkSize); i++) { const obj = { isBinary: isBinary || false, data: data.substr(i * Constants.WriteMaxChunkSize, Constants.WriteMaxChunkSize) }; this._writeQueue.push(obj); } </del> <ins> this._writeQueue.push(...chunkInput(data).map(e => { return { isBinary, data: e }; })); </ins> this._startWrite(); }


<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 { ensureNoDisposablesAreLeakedInTestSuite } from 'vs/base/test/common/utils'; import { chunkInput } from 'vs/platform/terminal/common/terminalProcess'; suite('platform - terminalProcess', () => { ensureNoDisposablesAreLeakedInTestSuite(); suite('chunkInput', () => { test('single chunk', () => { deepStrictEqual(chunkInput('foo bar'), ['foo bar']); }); test('multi chunk', () => { deepStrictEqual(chunkInput('foo'.repeat(50)), [ 'foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofo', 'ofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoof', 'oofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo' ]); }); test('small data with escapes', () => { deepStrictEqual(chunkInput('foo x1b[30mbar'), [ 'foo ', 'x1b[30mbar' ]); }); test('large data with escapes', () => { deepStrictEqual(chunkInput('foofoofoofoox1b[30mbarbarbarbarbarx1b[0m'.repeat(3)), [ 'foofoofoofoo', 'x1B[30mbarbarbarbarbar', 'x1B[0mfoofoofoofoo', 'x1B[30mbarbarbarbarbar', 'x1B[0mfoofoofoofoo', 'x1B[30mbarbarbarbarbar', 'x1B[0m' ]); }); }); }); </ins>


return id.toLocaleLowerCase(); } <del> export function getGalleryExtensionId(publisher: string, name: string): string { return adoptToGalleryExtensionId(getExtensionId(publisher, name)); </del> <ins> export function getGalleryExtensionId(publisher: string | undefined, name: string): string { return adoptToGalleryExtensionId(getExtensionId(publisher ?? UNDEFINED_PUBLISHER, name)); </ins> } export function groupByExtension<T>(extensions: T[], getExtensionIdentifier: (t: T) => IExtensionIdentifier): T[][] {


return true; } public override onLineMappingChanged(e: viewEvents.ViewLineMappingChangedEvent): boolean { <del> const keys = Object.keys(this._widgets); for (const widgetId of keys) { this._widgets[widgetId].onLineMappingChanged(e); } </del> <ins> this._updateAnchorsViewPositions(); </ins> return true; } public override onLinesChanged(e: viewEvents.ViewLinesChangedEvent): boolean { <ins> this._updateAnchorsViewPositions(); </ins> return true; } public override onLinesDeleted(e: viewEvents.ViewLinesDeletedEvent): boolean { <ins> this._updateAnchorsViewPositions(); </ins> return true; } public override onLinesInserted(e: viewEvents.ViewLinesInsertedEvent): boolean { <ins> this._updateAnchorsViewPositions(); </ins> return true; } public override onScrollChanged(e: viewEvents.ViewScrollChangedEvent): boolean {


openFolderInNewWindow = (windowConfig.openFoldersInNewWindow === 'on'); } <del> // Handle files to open/diff or to create when we dont open a folder if (!foldersToOpen.length && (filesToOpen.length > 0 || filesToCreate.length > 0 || filesToDiff.length > 0)) { </del> <ins> // Handle files to open/diff or to create when we dont open a folder and we do not restore any folder/untitled from hot-exit if (!foldersToOpen.length && !foldersToRestore.length && !emptyToRestore.length && (filesToOpen.length > 0 || filesToCreate.length > 0 || filesToDiff.length > 0)) { </ins> // let the user settings override how files are open in a new window or same window unless we are forced (not for extension development though) let openFilesInNewWindow: boolean;


argv.push(`--prof-startup-prefix`, filenamePrefix); argv.push(`--no-cached-data`); <del> writeFileAndFlushSync(filenamePrefix, argv.slice(-6).join('|')); </del> <ins> fs.writeFileSync(filenamePrefix, argv.slice(-6).join('|')); </ins> processCallbacks.push(async child => {


{ id: 'workspaceTrust', title: localize('gettingStarted.workspaceTrust.title', "Safely browse and edit code"), <del> description: localize('gettingStarted.workspaceTrust.description.interpolated', "{0} lets you decide whether your project folders should **allow or restrict** automatic code execution __(required for extensions, debugging, etc)__.nOpening a file/folder will prompt to grant trust. You can always {1} later.", Button(localize('workspaceTrust', "Workspace Trust"), 'https://github.com/microsoft/vscode-docs/blob/workspaceTrust/docs/editor/workspace-trust.md'), Button(localize('enableTrust', "enable trust"), 'command:toSide:workbench.action.manageTrustedDomain')), </del> <ins> description: localize('gettingStarted.workspaceTrust.description.interpolated', "{0} lets you decide whether your project folders should **allow or restrict** automatic code execution __(required for extensions, debugging, etc)__.nOpening a file/folder will prompt to grant trust. You can always {1} later.", Button(localize('workspaceTrust', "Workspace Trust"), 'https://code.visualstudio.com/docs/editor/workspace-trust'), Button(localize('enableTrust', "enable trust"), 'command:toSide:workbench.action.manageTrustedDomain')), </ins> when: 'workspacePlatform != 'webworker' && !isWorkspaceTrusted && workspaceFolderCount == 0', media: { type: 'svg', altText: 'Workspace Trust editor in Restricted mode and a primary button for switching to Trusted mode.', path: 'workspaceTrust.svg'


continue; } if (!m.lineRangeMapping.modified.isEmpty && m.lineRangeMapping.innerChanges) { <del> const btn = new RevertButton(m.lineRangeMapping.modified.startLineNumber, this._widget, m.lineRangeMapping.innerChanges, false); </del> <ins> const btn = store.add(new RevertButton(m.lineRangeMapping.modified.startLineNumber, this._widget, m.lineRangeMapping.innerChanges, false)); </ins> this._editors.modified.addGlyphMarginWidget(btn); glyphWidgetsModified.push(btn); }


} async function main(arch = process.arch): Promise<void> { <del> const version = product.electronRepository ? '22.5.3' : util.getElectronVersion(); </del> <ins> const version = product.electronRepository ? '22.5.4' : util.getElectronVersion(); </ins> const electronPath = path.join(root, '.build', 'electron'); const versionFile = path.join(electronPath, 'version'); const isUpToDate = fs.existsSync(versionFile) && fs.readFileSync(versionFile, 'utf8') === `${version}`;


private _pidPromiseComplete: (value: number) => any; private readonly _onData: Emitter<string> = new Emitter<string>(); <del> public get onData(): Event<string> { </del> <ins> public get onDidWriteData(): Event<string> { </ins> // Tell the main side to start sending data if it's not already this._proxy.$registerOnDataListener(this._id); return this._onData && this._onData.event;


return; } <del> const overrideToUse = typeof id === 'string' && allEditorOverrides.find(([_, entry]) => entry.id === id); </del> <ins> let overrideToUse; if (typeof id === 'string') { overrideToUse = allEditorOverrides.find(([_, entry]) => entry.id === id); } else if (allEditorOverrides.length === 1) { overrideToUse = allEditorOverrides[0]; } </ins> if (overrideToUse) { return overrideToUse[0].open(input, overrideOptions, group, OpenEditorContext.NEW_EDITOR)?.override; }


"git": { "name": "electron", "repositoryUrl": "https://github.com/electron/electron", <del> "commitHash": "0b17a201195ae6445e11cee50e436a3511717600" </del> <ins> "commitHash": "fcbd88f8aa27b1b603d267e5ebe0b7d748375c43" </ins> } }, "isOnlyProductionDependency": true, "license": "MIT", <del> "version": "22.3.5" </del> <ins> "version": "22.3.6" </ins> }, { "component": {


// handle the case where the mouse is over the view zone const viewZoneData = target.detail; if (controller.shouldShowHoverAtViewZone(viewZoneData.viewZoneId)) { <del> return new HoverForeignElementAnchor(1000, this, Range.fromPositions(this._editor.getModel()!.validatePosition(viewZoneData.positionBefore || viewZoneData.position)), mouseEvent.event.posx, mouseEvent.event.posy); </del> <ins> return new HoverForeignElementAnchor(1000, this, Range.fromPositions(this._editor.getModel()!.validatePosition(viewZoneData.positionBefore || viewZoneData.position)), mouseEvent.event.posx, mouseEvent.event.posy, false); </ins> } } if (target.type === MouseTargetType.CONTENT_EMPTY) { // handle the case where the mouse is over the empty portion of a line following ghost text if (controller.shouldShowHoverAt(target.range)) { <del> return new HoverForeignElementAnchor(1000, this, target.range, mouseEvent.event.posx, mouseEvent.event.posy); </del> <ins> return new HoverForeignElementAnchor(1000, this, target.range, mouseEvent.event.posx, mouseEvent.event.posy, false); </ins> } } if (target.type === MouseTargetType.CONTENT_TEXT) { // handle the case where the mouse is directly over ghost text const mightBeForeignElement = target.detail.mightBeForeignElement; if (mightBeForeignElement && controller.shouldShowHoverAt(target.range)) { <del> return new HoverForeignElementAnchor(1000, this, target.range, mouseEvent.event.posx, mouseEvent.event.posy); </del> <ins> return new HoverForeignElementAnchor(1000, this, target.range, mouseEvent.event.posx, mouseEvent.event.posy, false); </ins> } } return null;


this.message = localize('profileNameRequired', "Profile name is required."); return; } <del> if (this.name !== this.getInitialName() && this.userDataProfilesService.profiles.some(p => p.name === this.name)) { </del> <ins> if (this.shouldValidateName() && this.name !== this.getInitialName() && this.userDataProfilesService.profiles.some(p => p.name === this.name)) { </ins> this.message = localize('profileExists', "Profile with name {0} already exists.", this.name); return; }


bar.style.width = `${progress}%`; <del> (element.parentElement as HTMLElement).classList[stats.stepsComplete === 0 ? 'add' : 'remove']('no-progress'); </del> <ins> (element.parentElement as HTMLElement).classList.toggle('no-progress', stats.stepsComplete === 0); </ins> if (stats.stepsTotal === stats.stepsComplete) { bar.title = localize('gettingStarted.allStepsComplete', "All {0} steps complete!", stats.stepsComplete); } else { <del> bar.title = localize('gettingStarted.someStepsComplete', "{0} of {1} steps complete", stats.stepsTotal, stats.stepsComplete); </del> <ins> bar.title = localize('gettingStarted.someStepsComplete', "{0} of {1} steps complete", stats.stepsComplete, stats.stepsTotal); </ins> } }); }


name: cachedViewContainer.name, order: cachedViewContainer.order, pinned: cachedViewContainer.pinned, <del> visible: cachedViewContainer.visible, </del> <ins> visible: cachedViewContainer.visible && !!this.getViewContainer(cachedViewContainer.id), </ins> }); }


import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility'; import { BrowserAccessibilityService } from 'vs/platform/accessibility/common/accessibilityService'; import { ILayoutService } from 'vs/platform/layout/browser/layoutService'; <ins> import { ICodeLensCache, CodeLensCache } from 'vs/editor/contrib/codelens/codeLensCache'; </ins> export interface IEditorOverrideServices { [index: string]: any;


import { ILanguageService } from '../../../../editor/common/languages/language.js'; import { tokenizeToString } from '../../../../editor/common/languages/textToHtmlTokenizer.js'; import { IExtensionService } from '../../../services/extensions/common/extensions.js'; <ins> import { markedGfmHeadingIdPlugin } from './markedGfmHeadingIdPlugin.js'; </ins> export const DEFAULT_MARKDOWN_STYLES = ` body {


import { VIEW_PANE_ID, ISCMService, ISCMRepository, ISCMViewService } from 'vs/workbench/contrib/scm/common/scm'; import { IActivityService, NumberBadge } from 'vs/workbench/services/activity/common/activity'; import { IWorkbenchContribution } from 'vs/workbench/common/contributions'; <del> import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; </del> <ins> import { IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; </ins> import { IStatusbarService, StatusbarAlignment as MainThreadStatusBarAlignment } from 'vs/workbench/services/statusbar/browser/statusbar'; import { IEditorService } from 'vs/workbench/services/editor/common/editorService'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { EditorResourceAccessor } from 'vs/workbench/common/editor'; import { IUriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentity'; import { stripIcons } from 'vs/base/common/iconLabels'; <ins> import { Schemas } from 'vs/base/common/network'; </ins> function getCount(repository: ISCMRepository): number { if (typeof repository.provider.count === 'number') {


'out-build/vs/code/electron-browser/sharedProcess/sharedProcess.js', 'out-build/vs/code/electron-sandbox/issue/issueReporter.js', 'out-build/vs/code/electron-sandbox/processExplorer/processExplorer.js', <del> 'out-build/vs/platform/auth/common/auth.css', </del> <ins> 'out-build/vs/code/electron-sandbox/proxy/auth.js', </ins> '!**/test/**' ];


getAnchor: () => this._editorContainer, render: (container) => { return this._render(provider, container); <ins> }, onHide: () => { if (provider.options.type === AccessibleViewType.HelpMenu) { this._accessiblityHelpIsShown.reset(); } </ins> } }; this._contextViewService.showContextView(delegate); <ins> if (provider.options.type === AccessibleViewType.HelpMenu) { this._accessiblityHelpIsShown.set(true); } </ins> } private _render(provider: IAccessibleContentProvider, container: HTMLElement): IDisposable {


content.push(`.monaco-list${suffix}:focus .monaco-list-row.selected .codicon { color: ${styles.listActiveSelectionIconForeground}; }`); } <del> if (styles.listFocusAndSelectionOutline) { content.push(`.monaco-list${suffix}:focus .monaco-list-row.selected { outline-color: ${styles.listFocusAndSelectionOutline} !important; }`); } </del> if (styles.listFocusAndSelectionBackground) { content.push(` .monaco-drag-image,


const selections = getEndPositionsAfterApplying(edits).map(p => Selection.fromPositions(p)); editor.executeEdits('inlineSuggestion.accept', edits.map(edit => EditOperation.replace(edit.range, edit.text))); editor.setSelections(selections, 'inlineCompletionPartialAccept'); <ins> editor.revealPositionInCenterIfOutsideViewport(editor.getPosition()!, ScrollType.Immediate); </ins> } finally { this._isAcceptingPartially = false; }


} }, "node_modules/@xterm/addon-clipboard": { <del> "version": "0.2.0-beta.39", "resolved": "https://registry.npmjs.org/@xterm/addon-clipboard/-/addon-clipboard-0.2.0-beta.39.tgz", "integrity": "sha512-PeJZP69FHg2p1NJKLGyqUITahvEexqwYoQAgYheu4d9UBhIdP6D/KWGT8DVAEPeeulXhcr2UXgYWMVQAooTvrw==", </del> <ins> "version": "0.2.0-beta.47", "resolved": "https://registry.npmjs.org/@xterm/addon-clipboard/-/addon-clipboard-0.2.0-beta.47.tgz", "integrity": "sha512-mJHV1770gwVckj4mgjdxegt4zLL5WGCoJblTqaLbgEF7xOwsJUzvGk38qsZ4ZpdTa2ti76H0pkb1CpZGrXL9qg==", </ins> "dependencies": { "js-base64": "^3.7.5" }, "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/addon-image": { <del> "version": "0.9.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/addon-image/-/addon-image-0.9.0-beta.56.tgz", "integrity": "sha512-kwE4ZDlPxXsBk4mnQoqMvSwu9aKQclniIybs90t0L2qGPLcI8/7Akm1i9aXbu8eZF2hoLEPfLC3CZPda+4ioOA==", </del> <ins> "version": "0.9.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/addon-image/-/addon-image-0.9.0-beta.64.tgz", "integrity": "sha512-1Aqqytx/z/Khecf5xrO++f/p5EQX4uG87TbbAmE0OQys/JgKMnNggDzqon5bpHboimLfQiFPw716NbTqMphjfw==", </ins> "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/addon-search": { <del> "version": "0.16.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/addon-search/-/addon-search-0.16.0-beta.56.tgz", "integrity": "sha512-f8aoldPGssse1UR2N3f94fRUc7K3eulb+F80MFhim4rP+shX3QO9QdEZtwr+JaPEujjnuBM5tQKQDuRQtbwuMQ==", </del> <ins> "version": "0.16.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/addon-search/-/addon-search-0.16.0-beta.64.tgz", "integrity": "sha512-vUsvTkEOFJwv8nVtiiGr/vTMeQhu62VkUejY2h1+yZagnVEusGVPU1JYoqBTLu5HM4cFiTGsJYXFI/0apASXYA==", </ins> "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/addon-serialize": { <del> "version": "0.14.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/addon-serialize/-/addon-serialize-0.14.0-beta.56.tgz", "integrity": "sha512-VGAYJXFfXuY1Ze8CliT28DoYI74s8fdTI9919C0sgWwtzfAa7W43jJ56g0oKVEM0wO20wfdESapwpQ7enMzrHQ==", </del> <ins> "version": "0.14.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/addon-serialize/-/addon-serialize-0.14.0-beta.64.tgz", "integrity": "sha512-0AqVveTV3Pr9Lp+beJYOP5WuRvIrPSDGAK24da7BRGcLIKVq8pok1FdlM9jPeUbkX0DKo6Ortm77qeb2Z+n8+A==", </ins> "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/addon-unicode11": { <del> "version": "0.9.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/addon-unicode11/-/addon-unicode11-0.9.0-beta.56.tgz", "integrity": "sha512-oWa8xLWMDKgJboqOT57PaNAWYz+2INW5aUc24E0Nzv+gKXVy+8lRoqy50m3DhsOb1YtDaPVloqvambKBaXSing==", </del> <ins> "version": "0.9.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/addon-unicode11/-/addon-unicode11-0.9.0-beta.64.tgz", "integrity": "sha512-3+PKu+DXFq32xlsYfnI058/T8dTY2tQhRpJLP2CNR/jVWk5uBkVO0dBV0Srqj5QOAlAhzzZuS6TbsVRXORptqw==", </ins> "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/addon-webgl": { <del> "version": "0.19.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/addon-webgl/-/addon-webgl-0.19.0-beta.56.tgz", "integrity": "sha512-aYNRENPJBb1uoV7QifEwCnbjCXmQD5yQmuxNJab3bOZ68aCSGC/EKc4/4Ov0klkXi8ceF4ZnbNiqAX3jw5L1jg==", </del> <ins> "version": "0.19.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/addon-webgl/-/addon-webgl-0.19.0-beta.64.tgz", "integrity": "sha512-cxTkMPAXPQAZnWqahNu7ff9mbJvM1sQqKnZWiFZAHTsZXym4oa3KCB4pjH4didSyYkhkPY/17E8I0UOUpvv0Yw==", </ins> "peerDependencies": { <del> "@xterm/xterm": "^5.6.0-beta.56" </del> <ins> "@xterm/xterm": "^5.6.0-beta.64" </ins> } }, "node_modules/@xterm/headless": { <del> "version": "5.6.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/headless/-/headless-5.6.0-beta.56.tgz", "integrity": "sha512-aQOCzFDn/yqdATwf+ho1q5Hu2MzQwnXHgcsVx/qwUit/URKgbp1QyOQom88nzprP6D/59tiSeX+tqUS1HPqwMw==" </del> <ins> "version": "5.6.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/headless/-/headless-5.6.0-beta.64.tgz", "integrity": "sha512-my08kgH2K3CBEtBg/o8lamtD6BYNBv03Akq747Lajv0QzOiwan7B4r2xdbA6i9sovB+MdjFs0XP1ksc3EpKakg==" </ins> }, "node_modules/@xterm/xterm": { <del> "version": "5.6.0-beta.56", "resolved": "https://registry.npmjs.org/@xterm/xterm/-/xterm-5.6.0-beta.56.tgz", "integrity": "sha512-gtLrCQNkF1LikB21Bj9JYiBrrXMMvPEZkOIiA7MlXoSd7T7v+GYPumrODB2SBuhPdZ8N66z2rbUOfSRzxGwMtA==" </del> <ins> "version": "5.6.0-beta.64", "resolved": "https://registry.npmjs.org/@xterm/xterm/-/xterm-5.6.0-beta.64.tgz", "integrity": "sha512-iSKS6tQTFpoN5y487eptlxkUT0jqK5hrvtFQMLugMcQdn7gCUCiFGa4Z1RdqKYSGvAypka+b9gMKPrKWZ7Q3yQ==" </ins> }, "node_modules/@xtuc/ieee754": { "version": "1.2.0",


import { registerWindowDriver } from 'vs/platform/driver/electron-sandbox/driver'; import { ILabelService } from 'vs/platform/label/common/label'; import { dirname } from 'vs/base/common/resources'; <del> import { IUriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentity'; </del> export class NativeWindow extends Disposable {


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


let workbenchActionsRegistry = <IWorkbenchActionRegistry>Registry.as(ActionExtensions.WorkbenchActions); workbenchActionsRegistry.registerWorkbenchAction(new SyncActionDescriptor(SaveFileAsAction, SaveFileAsAction.ID, SaveFileAsAction.LABEL, { primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KEY_S }), category, ['save', 'as']); <del> workbenchActionsRegistry.registerWorkbenchAction(new SyncActionDescriptor(GlobalNewFileAction, GlobalNewFileAction.ID, GlobalNewFileAction.LABEL, { primary: KeyMod.CtrlCmd | KeyCode.KEY_N }), category, ['new', 'file']); </del> <ins> workbenchActionsRegistry.registerWorkbenchAction(new SyncActionDescriptor(GlobalNewUntitledFileAction, GlobalNewUntitledFileAction.ID, GlobalNewUntitledFileAction.LABEL, { primary: KeyMod.CtrlCmd | KeyCode.KEY_N }), category, ['new', 'untitled', 'file']); </ins> workbenchActionsRegistry.registerWorkbenchAction(new SyncActionDescriptor(GlobalCopyPathAction, GlobalCopyPathAction.ID, GlobalCopyPathAction.LABEL, { primary: KeyMod.chord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyCode.KEY_P) }), category, ['copy', 'path']); workbenchActionsRegistry.registerWorkbenchAction(new SyncActionDescriptor(GlobalRevealInOSAction, GlobalRevealInOSAction.ID, GlobalRevealInOSAction.LABEL, { primary: KeyMod.chord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyCode.KEY_R) }), category, ['reveal', 'file']);


export class EditorDictationStopAction extends EditorAction2 { <ins> static readonly ID = 'workbench.action.editorDictation.stop'; </ins> constructor() { super({ <del> id: 'workbench.action.editorDictation.stop', </del> <ins> id: EditorDictationStopAction.ID, </ins> title: localize2('stopDictation', "Stop Dictation in Editor"), category: VOICE_CATEGORY, precondition: EDITOR_DICTATION_IN_PROGRESS,


<ins> <?xml version="1.0" encoding="UTF-8"?> <mime-info xmlns="http://www.freedesktop.org/standards/shared-mime-info"> <mime-type type="application/x-@@NAME@@-workspace"> <comment>@@NAME_LONG@@ Workspace</comment> <glob pattern="*.code-workspace"/> </mime-type> </mime-info> </ins>


constructor( @IConfigurationService private readonly configurationService: IConfigurationService, @IBulkEditService private readonly bulkEditService: IBulkEditService, <ins> @IEditorService private readonly editorService: IEditorService, </ins> ) { } async participate(workingCopy: IStoredFileWorkingCopy<IStoredFileWorkingCopyModel>, context: { reason: SaveReason }, progress: IProgress<IProgressStep>, _token: CancellationToken): Promise<void> { if (this.configurationService.getValue('files.insertFinalNewline')) { <del> this.doInsertFinalNewLine(workingCopy, context, progress); </del> <ins> await this.doInsertFinalNewLine(workingCopy, context.reason === SaveReason.AUTO, progress); </ins> } } <del> private async doInsertFinalNewLine(workingCopy: IStoredFileWorkingCopy<IStoredFileWorkingCopyModel>, context: { reason: SaveReason }, progress: IProgress<IProgressStep>): Promise<void> { </del> <ins> private async doInsertFinalNewLine(workingCopy: IStoredFileWorkingCopy<IStoredFileWorkingCopyModel>, isAutoSaved: boolean, progress: IProgress<IProgressStep>): Promise<void> { </ins> if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) { return; }


"inputValidation.warningBorder": "#ffe055", "inputValidation.errorBackground": "#ffeaea", "inputValidation.errorBorder": "#f1897f", <del> "errorForeground": "#ffeaea", </del> <ins> "errorForeground": "#f1897f", </ins> "badge.background": "#705697AA", "progressBar.background": "#705697" }