resolved "https://registry.yarnpkg.com/@types/vscode-notebook-renderer/-/vscode-notebook-renderer-1.72.0.tgz#8943dc3cef0ced2dfb1e04c0a933bd289e7d5199" integrity sha512-5iTjb39DpLn03ULUwrDR3L2Dy59RV4blSUHy0oLdQuIY11PhgWO4mXIcoFS0VxY1GZQ4IcjSf3ooT2Jrrcahnw== <del> "@vscode/markdown-it-katex@^1.0.3": version "1.0.3" resolved "https://registry.yarnpkg.com/@vscode/markdown-it-katex/-/markdown-it-katex-1.0.3.tgz#5364e4dbcb0f7e7fd2fdab3847ba5d6b0c3ce9d9" integrity sha512-a8ppdac0CG2lAQC6E6lT8dxmXkUk9gRtYNtILx31FyrPEwj875AAHc6tpRGeJBpWMpiMtcvz7ymWYBwYgxuFmw== </del> <ins> "@vscode/markdown-it-katex@^1.1.0": version "1.1.0" resolved "https://registry.yarnpkg.com/@vscode/markdown-it-katex/-/markdown-it-katex-1.1.0.tgz#e991b58f6eb7cf56aef74b98e1a5edc1494649bb" integrity sha512-9cF2eJpsJOEs2V1cCAoJW/boKz9GQQLvZhNvI030K90z6ZE9lRGc9hDVvKut8zdFO2ObjwylPXXXVYvTdP2O2Q== </ins> dependencies: katex "^0.16.4"


import { INotificationService } from 'vs/platform/notification/common/notification'; import { IQuickInputService } from 'vs/platform/quickinput/common/quickInput'; import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage'; <del> import { IThemeService } from 'vs/platform/theme/common/themeService'; </del> <ins> import { IThemeService, themeColorFromId } from 'vs/platform/theme/common/themeService'; </ins> const SEARCH_STRING_MAX_LENGTH = 524288;


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


editor.focus(); }, next() { <del> model.next().then(() => show()); </del> <ins> contextViewService.hideContextView(); setTimeout(() => model.next().then(() => show()), 50); </ins> }, previous() { <del> model.previous().then(() => show()); </del> <ins> contextViewService.hideContextView(); setTimeout(() => model.previous().then(() => show()), 50); </ins> }, options: this._options });


order: 11 }); <ins> // --- Configure Tabs Layout export class ConfigureEditorTabsAction extends Action2 { static readonly ID = 'workbench.action.configureEditorTabs'; constructor() { super({ id: ConfigureEditorTabsAction.ID, title: localize2('configureTabs', "Configure Tabs ..."), category: Categories.View, }); } run(accessor: ServicesAccessor) { const preferencesService = accessor.get(IPreferencesService); preferencesService.openSettings({ jsonEditor: false, query: 'workbench.editor tab' }); } } registerAction2(ConfigureEditorTabsAction); // --- Configure Editor export class ConfigureEditorAction extends Action2 { static readonly ID = 'workbench.action.configureEditor'; constructor() { super({ id: ConfigureEditorAction.ID, title: localize2('configureEditor', "Configure Editor ..."), category: Categories.View, }); } run(accessor: ServicesAccessor) { const preferencesService = accessor.get(IPreferencesService); preferencesService.openSettings({ jsonEditor: false, query: 'workbench.editor' }); } } registerAction2(ConfigureEditorAction); </ins> // --- Toggle Pinned Tabs On Separate Row registerAction2(class extends Action2 {


// never wrap hidden editor result.wordWrapOverride1 = 'off'; result.wordWrapOverride2 = 'off'; <ins> result.stickyScroll = { enabled: false }; </ins> } else { result.wordWrapOverride1 = this._options.get().diffWordWrap; }


type: 'ptyHost', entryPoint: 'vs/platform/terminal/node/ptyHostMain', execArgv, <ins> args: ['--logsPath', this._environmentMainService.logsHome.fsPath], </ins> env: this._createPtyHostConfiguration(lastPtyId) });


} } <del> if (typeof anchorElementIndex === 'number') { </del> <ins> if (updateScrollTop && typeof anchorElementIndex === 'number') { </ins> this.scrollTop = this.elementTop(anchorElementIndex) - anchorElementTopDelta!; }


}); } <ins> async function runCommand(instance: ITerminalInstance, commandLine: string, addNewLine: boolean): Promise<void> { // Determine whether to send ETX (ctrl+c) before running the command. This should always // happen unless command detection can reliably say that a command is being entered and // there is no content in the prompt if (instance.capabilities.get(TerminalCapability.CommandDetection)?.hasInput !== false) { await instance.sendText('x03', false); // Wait a little before running the command to avoid the sequences being echoed while the ^C // is being evaluated await timeout(100); } // Use bracketed paste mode only when not running the command await instance.sendText(commandLine, addNewLine, !addNewLine); } </ins> class TerminalOutputProvider implements ITextModelContentProvider { static scheme = 'TERMINAL_OUTPUT';


}; function renderHTML(outputInfo: OutputItem, container: HTMLElement): void { <ins> clearContainer(container); </ins> const htmlContent = outputInfo.text(); const element = document.createElement('div'); const trustedHtml = ttPolicy?.createHTML(htmlContent) ?? htmlContent;


"editor.selectionHighlightBackground": "#ADD6FF4D", "editorSuggestWidget.background": "#F3F3F3", "activityBarBadge.background": "#007ACC", <del> "sideBarTitle.foreground": "#6F6F6F" </del> <ins> "sideBarTitle.foreground": "#6F6F6F", "list.hoverBackground": "#e0e0e0" </ins> } }  No newline at end of file


throw new Error(nls.localize('restartCode', "Please restart VS Code before reinstalling {0}.", this.manifest.displayName || this.manifest.name)); } } <del> } else { // Remove the extension with same version if it is already uninstalled. // Installing a VSIX extension shall replace the existing extension always. const existingWithSameVersion = await this.unsetIfUninstalled(this.extensionKey); if (existingWithSameVersion) { try { await this.extensionsScanner.removeExtension(existingWithSameVersion, 'existing'); } catch (e) { throw new Error(nls.localize('restartCode', "Please restart VS Code before reinstalling {0}.", this.manifest.displayName || this.manifest.name)); } </del> <ins> } // Remove the extension with same version if it is already uninstalled. // Installing a VSIX extension shall replace the existing extension always. const existingWithSameVersion = await this.unsetIfUninstalled(this.extensionKey); if (existingWithSameVersion) { try { await this.extensionsScanner.removeExtension(existingWithSameVersion, 'existing'); } catch (e) { throw new Error(nls.localize('restartCode', "Please restart VS Code before reinstalling {0}.", this.manifest.displayName || this.manifest.name)); </ins> } }


super({ id: 'chat.action.focus', title: localize2('actions.interactiveSession.focus', 'Focus Chat List'), <del> precondition: ContextKeyExpr.and(CONTEXT_IN_CHAT_INPUT, CONTEXT_CHAT_LOCATION.isEqualTo(ChatAgentLocation.Panel)), </del> <ins> precondition: ContextKeyExpr.and(CONTEXT_IN_CHAT_INPUT), </ins> category: CHAT_CATEGORY, keybinding: [ // On mac, require that the cursor is at the top of the input, to avoid stealing cmd+up to move the cursor to the top


.pipe(replace('@@UPDATEURL@@', product.updateUrl || '@@UPDATEURL@@')) .pipe(rename('DEBIAN/postinst')); <del> const all = es.merge(control, postinst, postrm, prerm, desktop, appdata, icon, code); </del> <ins> const all = es.merge(control, postinst, postrm, prerm, desktop, desktopUrlHandler, appdata, icon, code); </ins> return all.pipe(vfs.dest(destination)); };


default: true, markdownDescription: localize('interactiveWindow.alwaysScrollOnNewCell', "Automatically scroll the interactive window to show the output of the last statement executed. If this value is false, the window will only scroll if the last cell was already the one scrolled to.") }, <del> [InteractiveWindowSetting.interactiveWindowHotExit]: { </del> <ins> [InteractiveWindowSetting.interactiveWindowRestore]: { </ins> type: 'boolean', default: false, <del> markdownDescription: localize('interactiveWindow.hotExit', "Controls whether the interactive window sessions should be restored when the workspace reloads.") </del> <ins> markdownDescription: localize('interactiveWindow.restore', "Controls whether the Interactive Window sessions/history should be restored across window reloads. Whether the state of controllers used in Interactive Windows is persisted across window reloads are controlled by extensions contributing controllers.") </ins> } } });


import { ElementsDragAndDropData, ListViewTargetSector } from 'vs/base/browser/ui/list/listView'; import { IAsyncDataSource, ITreeContextMenuEvent, ITreeDragAndDrop, ITreeDragOverReaction, ITreeNode, ITreeRenderer, TreeDragOverBubble } from 'vs/base/browser/ui/tree/tree'; import { CollapseAllAction } from 'vs/base/browser/ui/tree/treeDefaults'; <del> import { ActionRunner, IAction } from 'vs/base/common/actions'; </del> <ins> import { ActionRunner, IAction, Separator } from 'vs/base/common/actions'; </ins> import { timeout } from 'vs/base/common/async'; import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation'; import { Codicon } from 'vs/base/common/codicons';


* and searches with the same session object can search the same cache. When the object is garbage-collected, the session is complete and the cache can be cleared. * Please do not store any references to the session object, except via a weak reference (e.g. `WeakRef` or `WeakMap`). */ <del> session: unknown; </del> <ins> session: object; </ins> /** * The maximum number of results to be returned.


import { IEditableData } from 'vs/workbench/common/views'; import { TerminalFindWidget } from 'vs/workbench/contrib/terminal/browser/terminalFindWidget'; import { ITerminalStatusList } from 'vs/workbench/contrib/terminal/browser/terminalStatusList'; <ins> import { ScrollPosition } from 'vs/workbench/contrib/terminal/browser/xterm/markNavigationAddon'; </ins> import { ITerminalQuickFixAddon } from 'vs/workbench/contrib/terminal/browser/xterm/quickFixAddon'; import { INavigationMode, IRegisterContributedProfileArgs, IRemoteTerminalAttachTarget, IStartExtensionTerminalRequest, ITerminalBackend, ITerminalConfigHelper, ITerminalFont, ITerminalProcessExtHostProxy } from 'vs/workbench/contrib/terminal/common/terminal'; import { EditorGroupColumn } from 'vs/workbench/services/editor/common/editorGroupColumn';


const os = this._processManager.os || OS; const parsedLinks = detectLinks(text, os); <ins> this._logService.trace('terminalLocaLinkDetector#detect text', text); this._logService.trace('terminalLocaLinkDetector#detect parsedLinks', parsedLinks); </ins> for (const parsedLink of parsedLinks) { // Don't try resolve any links of excessive length if (parsedLink.path.text.length > Constants.MaxResolvedLinkLength) { continue;


} })); <del> this.toDispose.push(dom.addDisposableListener(this.selectElement, dom.EventType.MOUSE_UP, (e) => { dom.EventHelper.stop(e); })); </del> this.toDispose.push(dom.addDisposableListener(this.selectElement, dom.EventType.MOUSE_DOWN, (e) => { dom.EventHelper.stop(e); })); // Intercept keyboard handling <del> this.toDispose.push(dom.addDisposableListener(this.selectElement, dom.EventType.KEY_UP, (e: KeyboardEvent) => { dom.EventHelper.stop(e); })); </del> this.toDispose.push(dom.addDisposableListener(this.selectElement, dom.EventType.KEY_DOWN, (e: KeyboardEvent) => { const event = new StandardKeyboardEvent(e); let showDropDown = false;


return this._dirty; } <ins> isUntitled() { return this._notebook.uri.scheme === Schemas.untitled; } </ins> getNotebook(): NotebookTextModel { return this._notebook; }


} }; this._contextViewService.showContextView(delegate); <ins> if (lineNumber) { // Context view takes time to show up, so we need to wait for it to show up before we can set the position setTimeout(() => { this._editorWidget.revealLine(lineNumber); this._editorWidget.setSelection({ startLineNumber: lineNumber, startColumn: 1, endLineNumber: lineNumber, endColumn: 1 }); }, 50); } </ins> if (symbol && this._currentProvider) { this.showSymbol(this._currentProvider, symbol); }


getMergeBase(ref1: string, ref2: string): Promise<string>; <ins> tag(name: string, upstream: string): Promise<void>; deleteTag(name: string): Promise<void>; </ins> status(): Promise<void>; checkout(treeish: string): Promise<void>;


parameters: VSCODE_QUALITY: ${{ variables.VSCODE_QUALITY }} VSCODE_BUILD_LINUX_ALPINE_ARM64: ${{ parameters.VSCODE_BUILD_LINUX_ALPINE_ARM64 }} <del> VSCODE_BUILD_LINUX_ARM64: ${{ parameters.VSCODE_BUILD_LINUX_ARM64 }} VSCODE_BUILD_LINUX_ARMHF: ${{ parameters.VSCODE_BUILD_LINUX_ARMHF }} - ${{ if eq(variables.VSCODE_BUILD_STAGE_MACOS, true) }}: - job: MacOS </del> <ins> - ${{ if eq(parameters.VSCODE_BUILD_MACOS, true) }}: - job: MacOSX64 </ins> pool: vmImage: macOS-11 steps:


import { EditorPaneDescriptor, IEditorPaneRegistry } from 'vs/workbench/browser/editor'; import { Extensions as WorkbenchExtensions, IWorkbenchContributionsRegistry } from 'vs/workbench/common/contributions'; import { EditorExtensions, IEditorFactoryRegistry } from 'vs/workbench/common/editor'; <del> import { AcceptAllInput1, AcceptAllInput2, AcceptMerge, CompareInput1WithBaseCommand, CompareInput2WithBaseCommand, GoToNextUnhandledConflict, GoToPreviousUnhandledConflict, OpenBaseFile, OpenMergeEditor, OpenResultResource, ResetToBaseAndAutoMergeCommand, SetColumnLayout, SetMixedLayout, ShowHideAtTopBase, ShowHideBase, ShowNonConflictingChanges, ToggleActiveConflictInput1, ToggleActiveConflictInput2 } from 'vs/workbench/contrib/mergeEditor/browser/commands/commands'; </del> <ins> import { AcceptAllInput1, AcceptAllInput2, AcceptMerge, CompareInput1WithBaseCommand, CompareInput2WithBaseCommand, GoToNextUnhandledConflict, GoToPreviousUnhandledConflict, OpenBaseFile, OpenMergeEditor, OpenResultResource, ResetToBaseAndAutoMergeCommand, SetColumnLayout, SetMixedLayout, ShowHideTopBase, ShowHideCenterBase, ShowHideBase, ShowNonConflictingChanges, ToggleActiveConflictInput1, ToggleActiveConflictInput2 } from 'vs/workbench/contrib/mergeEditor/browser/commands/commands'; </ins> import { MergeEditorCopyContentsToJSON, MergeEditorLoadContentsFromFolder, MergeEditorSaveContentsToFolder } from 'vs/workbench/contrib/mergeEditor/browser/commands/devCommands'; import { MergeEditorInput } from 'vs/workbench/contrib/mergeEditor/browser/mergeEditorInput'; import { MergeEditor, MergeEditorOpenHandlerContribution, MergeEditorResolverContribution } from 'vs/workbench/contrib/mergeEditor/browser/view/mergeEditor';


if (lineNumber === undefined) { return; } <del> this.show(provider); this._editorWidget.revealLine(lineNumber); this._editorWidget.setSelection({ startLineNumber: lineNumber, startColumn: 1, endLineNumber: lineNumber, endColumn: 1 }); </del> <ins> this.show(provider, undefined, undefined, lineNumber); </ins> this._updateContextKeys(provider, true); }


} async acceptInput() { <del> assertType(this._activeSession); </del> assertType(this._widget); <ins> await this._sessionCtor; assertType(this._activeSession); </ins> this._warmupRequestCts?.dispose(true); this._warmupRequestCts = undefined; this._activeSession.addInput(new SessionPrompt(this._widget.inlineChatWidget.value));


{ "displayName": "Markdown Math", "description": "Adds math support to Markdown in notebooks.", <del> "config.markdown.math.enabled": "Enable/disable rendering math in the built-in Markdown preview." </del> <ins> "config.markdown.math.enabled": "Enable/disable rendering math in the built-in Markdown preview.", "config.markdown.math.macros": "A collection of custom macros. Each macro is a key-value pair where the key is a new command name and the value is the expansion of the macro." </ins> }


const config = workspace.getConfiguration('git', Uri.file(this.repository.root)); const showActionButton = config.get<{ publish: boolean }>('showActionButton', { publish: true }); <del> // Branch does have an upstream, commit/merge/rebase is in progress, or the button is disabled if (this.state.HEAD?.upstream || this.state.isCommitInProgress || this.state.isMergeInProgress || this.state.isRebaseInProgress || !showActionButton.publish) { return undefined; } </del> <ins> // Not a branch (tag, detached), branch does have an upstream, commit/merge/rebase is in progress, or the button is disabled if (!this.state.HEAD?.name || this.state.HEAD?.upstream || this.state.isCommitInProgress || this.state.isMergeInProgress || this.state.isRebaseInProgress || !showActionButton.publish) { return undefined; } </ins> // Button icon const icon = this.state.isSyncInProgress ? '$(sync~spin)' : '$(cloud-upload)';


return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables); } <ins> export function runAndSubscribeEvent<T>(event: Event<T>, handler: (e: T) => any, initial: T): IDisposable; export function runAndSubscribeEvent<T>(event: Event<T>, handler: (e: T | undefined) => any): IDisposable; export function runAndSubscribeEvent<T>(event: Event<T>, handler: (e: T | undefined) => any, initial?: T): IDisposable { handler(initial); return event(e => handler(e)); } </ins> export function anyEvent<T>(...events: Event<T>[]): Event<T> { return (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => { const result = combinedDisposable(events.map(event => event(i => listener.call(thisArgs, i))));


let mut addr = url::Url::parse("https://insiders.vscode.dev").unwrap(); { let mut ps = addr.path_segments_mut().unwrap(); <del> ps.push(extension_name); </del> <ins> ps.push("tunnel"); </ins> ps.push(tunnel_name); for segment in &dir { let as_str = segment.to_string_lossy();


return super.saveTextEditorViewState(arg1); } <del> if (arg1 instanceof UntitledEditorInput && !arg1.isDisposed()) { </del> <ins> if ((arg1 instanceof UntitledEditorInput || arg1 instanceof ResourceEditorInput) && !arg1.isDisposed()) { </ins> return super.saveTextEditorViewState(arg1.getResource().toString()); } }


} const firstPageElement = this.view.element(firstPageIndex); <del> const currentlyFocusedElement = this.getFocusedElements()[0]; </del> <ins> const currentlyFocusedElementIndex = this.getFocus()[0]; const currentlyFocusedElement = this.view.element(currentlyFocusedElementIndex); </ins> <del> if (currentlyFocusedElement !== firstPageElement) { </del> <ins> if (currentlyFocusedElement !== firstPageElement && currentlyFocusedElementIndex >= firstPageIndex) { </ins> const firstGoodPageIndex = this.findNextIndex(firstPageIndex, false, filter); if (firstGoodPageIndex > -1 && currentlyFocusedElement !== this.view.element(firstGoodPageIndex)) {


this._register(this.instantiationService.createInstance(NotebookEditorContextKeys, this)); <del> this._notebookOutline = this.instantiationService.createInstance(NotebookCellOutlineProvider, this, OutlineTarget.QuickPick); </del> <ins> this._notebookOutline = this._register(this.instantiationService.createInstance(NotebookCellOutlineProvider, this, OutlineTarget.QuickPick)); </ins> this._register(notebookKernelService.onDidChangeSelectedNotebooks(e => { if (isEqual(e.notebook, this.viewModel?.uri)) {


path: 'tmux' } }, <ins> additionalProperties: terminalProfileSchema </ins> }, 'terminal.integrated.profiles.linux': { markdownDescription: localize(


// Based on testing, the trigger character is always at the end of the query. // for the ':' trigger, only return suggestions if there was a '@' before it in the same word. const queryParts = query.split(/s/g); <del> if (queryParts[queryParts.length - 1].startsWith('@')) { </del> <ins> if (queryParts[queryParts.length - 1].startsWith(`@${LANGUAGE_SETTING_TAG}`)) { return this.languageService.getRegisteredLanguageIds().map(languageId => { return `@${LANGUAGE_SETTING_TAG}${languageId} `; }).sort(); } else if (queryParts[queryParts.length - 1].startsWith('@')) { </ins> return SettingsEditor2.SUGGESTIONS.filter(tag => !query.includes(tag)).map(tag => tag.endsWith(':') ? tag : tag + ' '); } return [];


for (( i=0; i < "${#str}"; ++i )); do byte="${str:$i:1}" <del> # Escape backslashes, semi-colons specially, then special ASCII chars below space (0x20) </del> <ins> # Escape backslashes, semi-colons specially, then special ASCII chars below space (0x20). # This is done in an unwrapped loop instead of using printf as the latter is very slow. </ins> if [ "$byte" = "" ]; then token="" elif [ "$byte" = ";" ]; then token="x3b" <del> elif (( $(builtin printf '%d' "'$byte") < 31 )); then token=$(builtin printf 'x%02x' "'$byte") </del> <ins> elif [ "$byte" = $'x00' ]; then token="x00" elif [ "$byte" = $'x01' ]; then token="x01" elif [ "$byte" = $'x02' ]; then token="x02" elif [ "$byte" = $'x03' ]; then token="x03" elif [ "$byte" = $'x04' ]; then token="x04" elif [ "$byte" = $'x05' ]; then token="x05" elif [ "$byte" = $'x06' ]; then token="x06" elif [ "$byte" = $'x07' ]; then token="x07" elif [ "$byte" = $'x08' ]; then token="x08" elif [ "$byte" = $'x09' ]; then token="x09" elif [ "$byte" = $'x0a' ]; then token="x0a" elif [ "$byte" = $'x0b' ]; then token="x0b" elif [ "$byte" = $'x0c' ]; then token="x0c" elif [ "$byte" = $'x0d' ]; then token="x0d" elif [ "$byte" = $'x0e' ]; then token="x0e" elif [ "$byte" = $'x0f' ]; then token="x0f" elif [ "$byte" = $'x10' ]; then token="x10" elif [ "$byte" = $'x11' ]; then token="x11" elif [ "$byte" = $'x12' ]; then token="x12" elif [ "$byte" = $'x13' ]; then token="x13" elif [ "$byte" = $'x14' ]; then token="x14" elif [ "$byte" = $'x15' ]; then token="x15" elif [ "$byte" = $'x16' ]; then token="x16" elif [ "$byte" = $'x17' ]; then token="x17" elif [ "$byte" = $'x18' ]; then token="x18" elif [ "$byte" = $'x19' ]; then token="x19" elif [ "$byte" = $'x1a' ]; then token="x1a" elif [ "$byte" = $'x1b' ]; then token="x1b" elif [ "$byte" = $'x1c' ]; then token="x1c" elif [ "$byte" = $'x1d' ]; then token="x1d" elif [ "$byte" = $'x1e' ]; then token="x1e" elif [ "$byte" = $'x1f' ]; then token="x1f" </ins> else token="$byte" fi


this.update(); } <del> get valueSelection() { const selection = this.ui.inputBox.getSelection(); if (!selection) { return undefined; } return [selection.start, selection.end]; } set valueSelection(valueSelection: Readonly<[number, number]> | undefined) { </del> <ins> set valueSelection(valueSelection: Readonly<[number, number]>) { </ins> this._valueSelection = valueSelection; this.valueSelectionUpdated = true; this.update();


@IInstantiationService instantiationService: IInstantiationService, @IWorkspaceContextService private contextService: IWorkspaceContextService, @IStorageService storageService: IStorageService, <del> @IHistoryService private historyService: IHistoryService, </del> @ITextResourceConfigurationService configurationService: ITextResourceConfigurationService, @IWorkbenchEditorService private editorService: IWorkbenchEditorService, @IThemeService themeService: IThemeService,


private _sortByLabel = true; private _autoFocusOnList = true; private _keepScrollPosition = false; <del> private _itemActivation = this.ui.isScreenReaderOptimized() ? ItemActivation.NONE /* https://github.com/microsoft/vscode/issues/57501 */ : ItemActivation.FIRST; </del> <ins> private _itemActivation = ItemActivation.FIRST; </ins> private _activeItems: T[] = []; private activeItemsUpdated = false; private activeItemsToConfirm: T[] | null = [];


this.element.ariaRoleDescription = localize('terminal.integrated.accessibleBuffer', 'Terminal buffer'); _instance.onDidRequestFocus(() => this.hide(true)); this.updateEditor(); <del> this.add(this.editorWidget.onDidFocusEditorText(async () => { if (this.element.classList.contains(ClassName.Active)) { // the user has focused the editor via mouse or // Go to Command was run so we've already updated the editor return; } // if the editor is focused via tab, we need to update the model // and show it this.registerListeners(); await this.updateEditor(); this.element.classList.add(ClassName.Active); })); </del> // xterm's initial layout call has already happened this.layout(); }


"html.mirrorCursorOnMatchingTag": { "type": "boolean", "scope": "resource", <del> "default": true, </del> <ins> "default": false, </ins> "description": "%html.mirrorCursorOnMatchingTag%" }, "html.trace.server": {


return; } <del> await ensurePublished(gitRepo, uri); </del> <ins> if (shouldEnsurePublished) { await ensurePublished(gitRepo, uri); } </ins> let repo: { owner: string; repo: string } | undefined; gitRepo.state.remotes.find(remote => {


id: ShowCurrentReleaseNotesActionId, title: { value: localize('showReleaseNotes', "Show Release Notes"), <del> mnemonicTitle: localize('mshowReleaseNotes', "Show &&Release Notes"), </del> <ins> mnemonicTitle: localize({ key: 'mshowReleaseNotes', comment: ['&& denotes a mnemonic'] }, "Show &&Release Notes"), </ins> original: 'Show Release Notes' }, category: { value: product.nameShort, original: product.nameShort },


return; } <del> await result.repository.applyStash(result.stash.index); </del> await commands.executeCommand('workbench.action.closeActiveEditor'); <ins> await result.repository.applyStash(result.stash.index); </ins> } @command('git.stashDrop', { repository: true })


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ import * as assert from 'assert'; import { Registry } from 'vs/platform/registry/common/platform'; import { IConfigurationRegistry, Extensions as ConfigurationExtensions } from 'vs/platform/configuration/common/configurationRegistry'; suite('ConfigurationRegistry', () => { const configurationRegistry = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration); test('configuration override', async () => { configurationRegistry.registerConfiguration({ 'id': '_test_default', 'type': 'object', 'properties': { 'config': { 'type': 'object', } } }); configurationRegistry.registerDefaultConfigurations([{ 'config': { a: 1, b: 2 } }]); configurationRegistry.registerDefaultConfigurations([{ '[lang]': { a: 2, c: 3 } }]); assert.deepEqual(configurationRegistry.getConfigurationProperties()['config'].default, { a: 1, b: 2 }); assert.deepEqual(configurationRegistry.getConfigurationProperties()['[lang]'].default, { a: 2, c: 3 }); }); test('configuration override defaults - merges defaults', async () => { configurationRegistry.registerDefaultConfigurations([{ '[lang]': { a: 1, b: 2 } }]); configurationRegistry.registerDefaultConfigurations([{ '[lang]': { a: 2, c: 3 } }]); assert.deepEqual(configurationRegistry.getConfigurationProperties()['[lang]'].default, { a: 2, b: 2, c: 3 }); }); test('configuration defaults - overrides defaults', async () => { configurationRegistry.registerConfiguration({ 'id': '_test_default', 'type': 'object', 'properties': { 'config': { 'type': 'object', } } }); configurationRegistry.registerDefaultConfigurations([{ 'config': { a: 1, b: 2 } }]); configurationRegistry.registerDefaultConfigurations([{ 'config': { a: 2, c: 3 } }]); assert.deepEqual(configurationRegistry.getConfigurationProperties()['config'].default, { a: 2, c: 3 }); }); }); </ins>


@IFileService private readonly fileService: IFileService ) { super(lifecycleMainService, configurationService, environmentService, requestService, logService); <ins> } initialize(): void { super.initialize(); </ins> if (getUpdateType() === UpdateType.Setup) { /* __GDPR__


@ITextFileService private readonly textFileService: ITextFileService, @IExplorerService private readonly explorerService: IExplorerService, @IUriIdentityService private readonly uriIdentityService: IUriIdentityService, <del> @IPathService private readonly pathService: IPathService </del> <ins> @IPathService private readonly pathService: IPathService, @IConfigurationService private readonly configurationService: IConfigurationService </ins> ) { super(TextFileEditor.ID, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService);


for (const defaultConfiguration of defaultConfigurations) { for (const key in defaultConfiguration) { properties.push(key); <del> this.defaultValues[key] = defaultConfiguration[key]; </del> if (OVERRIDE_PROPERTY_PATTERN.test(key)) { <ins> this.defaultValues[key] = { ...(this.defaultValues[key] || {}), ...defaultConfiguration[key] }; </ins> const property: IConfigurationPropertySchema = { type: 'object', default: this.defaultValues[key],


type: string - name: VSCODE_BUILD_MACOS type: boolean <ins> default: false </ins> - name: VSCODE_BUILD_MACOS_ARM64 type: boolean <ins> default: false </ins> - name: channel type: string default: stable


return; } <del> const root = element instanceof SearchResult ? null : element; this.tree.setChildren(root, this.createIterator(element, collapseResults)); </del> <ins> if (element instanceof SearchResult) { this.tree.setChildren(null, this.createIterator(element, collapseResults)); } else { this.tree.setChildren(element, this.createIterator(element, collapseResults)); this.tree.rerender(element); } </ins> }); } }


id: 'editor.action.inlineSuggest.acceptNextWord', label: nls.localize('action.inlineSuggest.acceptNextWord', "Accept Next Word Of Inline Suggestion"), alias: 'Accept Next Word Of Inline Suggestion', <del> precondition: EditorContextKeys.writable </del> <ins> precondition: ContextKeyExpr.and(EditorContextKeys.writable, GhostTextController.inlineSuggestionVisible), kbOpts: { weight: 1000, primary: KeyMod.CtrlCmd | KeyCode.RightArrow, } </ins> }); }


{ "scope": "markup.heading", "settings": { <ins> "fontStyle": "bold", </ins> "foreground": "#6796e6" } },


*/ toString(skipEncoding?: boolean): string; toJSON(): UriComponents; <ins> /** * A helper function to revive URIs. * * **Note** that this function should only be used when receiving Uri#toJSON generated data * and that it doesn't do any validation. Use {@link Uri.from} when received "untrusted" * uri components such as command arguments or data from storage. * * @param data The Uri components or Uri to revive. * @returns The revived Uri or undefined or null. */ </ins> static revive(data: UriComponents | Uri): Uri; static revive(data: UriComponents | Uri | undefined): Uri | undefined; static revive(data: UriComponents | Uri | null): Uri | null;


isItemVisible(item: ExplorerItem): boolean; isItemCollapsed(item: ExplorerItem): boolean; hasFocus(): boolean; <ins> getFocus(): ExplorerItem[]; focusNext(): void; focusLast(): void; </ins> } function getFocus(listService: IListService): unknown | undefined {


export async function getInlayHints(model: ITextModel, ranges: Range[], token: CancellationToken): Promise<InlayHintsData[]> { const datas: InlayHintsData[] = []; const providers = InlayHintsProviderRegistry.ordered(model).reverse(); <del> const promises = flatten(providers.map(provider => ranges.map(range => Promise.resolve(provider.provideInlayHints(model, range, token)).then(result => { if (result) { datas.push({ list: result, provider }); } }, err => { onUnexpectedExternalError(err); })))); </del> <ins> const promises = flatten(providers.map(provider => ranges.map(range => { return Promise.resolve(provider.provideInlayHints(model, range, token)).then(result => { const itemsInRange = result?.filter(hint => range.containsPosition(hint.position)); if (itemsInRange?.length) { datas.push({ list: itemsInRange, provider }); } }, err => { onUnexpectedExternalError(err); }); }))); </ins> await Promise.all(promises);


box-shadow: none; } <ins> .hc-black .monaco-menu .monaco-action-bar.vertical .action-item { border: 1px solid transparent; /* prevents jumpig behaviour on hover or focus */ } </ins> .hc-black .monaco-menu .monaco-action-bar.vertical .action-item.focused { background: none; border: 1px dotted #f38518;


return this.shouldShowCompositeBar() ? super.getVisiblePaneCompositeIds() : this.acitivityBarPart.getVisiblePaneCompositeIds(); } <del> focusActivityBar(): void { </del> <ins> async focusActivityBar(): Promise<void> { if (this.configurationService.getValue(LayoutSettings.ACTIVITY_BAR_LOCATION) === ActivityBarPosition.HIDDEN) { await this.configurationService.updateValue(LayoutSettings.ACTIVITY_BAR_LOCATION, this.getRememberedActivityBarVisiblePosition()); this.onDidChangeActivityBarLocation(); } </ins> if (this.shouldShowCompositeBar()) { this.focusComositeBar(); } else { if (!this.layoutService.isVisible(Parts.ACTIVITYBAR_PART)) { this.layoutService.setPartHidden(false, Parts.ACTIVITYBAR_PART); } <del> this.acitivityBarPart.focus(); </del> <ins> this.acitivityBarPart.show(true); </ins> } }


import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection'; import { IStorageService } from 'vs/platform/storage/common/storage'; import { IThemeService } from 'vs/platform/theme/common/themeService'; <del> import { hasCustomTitlebar } from 'vs/platform/window/common/window'; </del> <ins> import { hasNativeTitlebar } from 'vs/platform/window/common/window'; </ins> import { IEditorGroupView, IEditorPartsView } from 'vs/workbench/browser/parts/editor/editor'; import { EditorPart, IEditorPartUIState } from 'vs/workbench/browser/parts/editor/editorPart'; import { IAuxiliaryTitlebarPart } from 'vs/workbench/browser/parts/titlebar/titlebarPart';


export class ExplorerViewPaneContainer extends ViewPaneContainer { <del> private viewletVisibleContextKey: IContextKey<boolean>; </del> constructor( @IWorkbenchLayoutService layoutService: IWorkbenchLayoutService, @ITelemetryService telemetryService: ITelemetryService,


import URI from 'vs/base/common/uri'; import * as errors from 'vs/base/common/errors'; import { TPromise } from 'vs/base/common/winjs.base'; <ins> import * as arrays from 'vs/base/common/arrays'; </ins> import * as objects from 'vs/base/common/objects'; import * as DOM from 'vs/base/browser/dom'; import { Separator } from 'vs/base/browser/ui/actionbar/actionbar';


$Nonce = $env:VSCODE_NONCE $env:VSCODE_NONCE = $null <ins> $osVersion = [System.Environment]::OSVersion.Version $isWindows10 = $IsWindows10 -and $osVersion.Major -eq 10 -and $osVersion.Minor -eq 0 -and $osVersion.Build -lt 22000 </ins> if ($env:VSCODE_ENV_REPLACE) { $Split = $env:VSCODE_ENV_REPLACE.Split(":") foreach ($Item in $Split) {


export interface EditSession { version: number; <ins> machine?: string; </ins> folders: Folder[]; }


return path.split('/').map((segment) => encodeURIComponent(segment)).join('/'); } <del> export async function getLink(gitAPI: GitAPI, useSelection: boolean, hostPrefix?: string, linkType: 'permalink' | 'headlink' = 'permalink', context?: LinkContext, useRange?: boolean): Promise<string | undefined> { </del> <ins> export async function getLink(gitAPI: GitAPI, useSelection: boolean, shouldEnsurePublished: boolean, hostPrefix?: string, linkType: 'permalink' | 'headlink' = 'permalink', context?: LinkContext, useRange?: boolean): Promise<string | undefined> { </ins> hostPrefix = hostPrefix ?? 'https://github.com'; const fileAndPosition = getFileAndPosition(context); if (!fileAndPosition) {


public readonly inlineCompletionVisible = GhostTextController.inlineSuggestionVisible.bindTo(this.contextKeyService); public readonly inlineCompletionSuggestsIndentation = GhostTextController.inlineSuggestionHasIndentation.bindTo(this.contextKeyService); public readonly inlineCompletionSuggestsIndentationLessThanTabSize = GhostTextController.inlineSuggestionHasIndentationLessThanTabSize.bindTo(this.contextKeyService); <ins> public readonly inlineSuggestionJustCommitted = GhostTextController.inlineSuggestionJustCommitted.bindTo(this.contextKeyService); </ins> constructor(private readonly contextKeyService: IContextKeyService) { }


onSelectDropDownKeyDown.filter(e => e.keyCode === KeyCode.Escape).on(e => this.onEscape(e), this, this.toDispose); onSelectDropDownKeyDown.filter(e => e.keyCode === KeyCode.UpArrow).on(this.onUpArrow, this, this.toDispose); onSelectDropDownKeyDown.filter(e => e.keyCode === KeyCode.DownArrow).on(this.onDownArrow, this, this.toDispose); <ins> onSelectDropDownKeyDown.filter(e => (e.keyCode >= KeyCode.KEY_0 && e.keyCode <= KeyCode.KEY_Z) || (e.keyCode >= KeyCode.US_SEMICOLON && e.keyCode <= KeyCode.NUMPAD_DIVIDE)).on(this.onCharacter, this, this.toDispose); </ins> // SetUp list mouse controller - control navigation, disabled items, focus


public commitPartially(): void { this.activeModel?.commitInlineCompletionPartially(); <ins> this.activeController?.value?.contextKeys.inlineSuggestionJustCommitted.set(true); </ins> } public commit(): void { this.activeModel?.commitInlineCompletion(); <ins> this.activeController?.value?.contextKeys.inlineSuggestionJustCommitted.set(true); </ins> } public hide(): void {


import { Repository, GitResourceGroup } from './repository'; import { Model } from './model'; import { debounce } from './decorators'; <del> import { filterEvent, dispose, anyEvent, fireEvent, PromiseSource, combinedDisposable } from './util'; </del> <ins> import { filterEvent, dispose, anyEvent, fireEvent, PromiseSource, combinedDisposable, runAndSubscribeEvent } from './util'; </ins> import { Change, GitErrorCodes, Status } from './api/git'; class GitIgnoreDecorationProvider implements FileDecorationProvider {


if (isEnabled()) { const katex = require('@vscode/markdown-it-katex').default; const settingsMacros = getMacros(); <del> const options = { globalGroup: true, macros: { ...settingsMacros } }; </del> <ins> const options = { enableFencedBlocks: true, globalGroup: true, macros: { ...settingsMacros } }; </ins> md.core.ruler.push('reset-katex-macros', () => { options.macros = { ...settingsMacros }; });


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


this._accessibleViewCurrentProviderId.reset(); } <del> show(provider?: IAccessibleContentProvider, symbol?: IAccessibleViewSymbol, showAccessibleViewHelp?: boolean): void { </del> <ins> show(provider?: IAccessibleContentProvider, symbol?: IAccessibleViewSymbol, showAccessibleViewHelp?: boolean, lineNumber?: number): void { </ins> provider = provider ?? this._currentProvider; if (!provider) { return;


isFeatureTerminal: launchConfig.isFeatureTerminal, isExtensionOwnedTerminal: launchConfig.isExtensionOwnedTerminal, useShellEnvironment: launchConfig.useShellEnvironment, <ins> disablePersistence: launchConfig.disablePersistence </ins> }; const terminal = Promises.withAsyncBody<ITerminalInstance>(async r => { const terminal = await this._terminalService.createTerminal({


import { Codicon } from 'vs/base/common/codicons'; import { ICodeEditor } from 'vs/editor/browser/editorBrowser'; <del> import { IModelDecorationOptions, IModelDecorationsChangeAccessor, TrackedRangeStickiness } from 'vs/editor/common/model'; </del> <ins> import { IModelDecorationOptions, IModelDecorationsChangeAccessor, MinimapPosition, TrackedRangeStickiness } from 'vs/editor/common/model'; </ins> import { ModelDecorationOptions } from 'vs/editor/common/model/textModel'; import { IDecorationProvider } from 'vs/editor/contrib/folding/browser/foldingModel'; import { localize } from 'vs/nls'; <ins> import { editorSelectionBackground, iconForeground, registerColor, transparent } from 'vs/platform/theme/common/colorRegistry'; </ins> import { registerIcon } from 'vs/platform/theme/common/iconRegistry'; <del> import { ThemeIcon } from 'vs/platform/theme/common/themeService'; </del> <ins> import { themeColorFromId, ThemeIcon } from 'vs/platform/theme/common/themeService'; const foldBackground = registerColor('editor.foldBackground', { light: transparent(editorSelectionBackground, 0.3), dark: transparent(editorSelectionBackground, 0.3), hcDark: null, hcLight: null }, localize('foldBackgroundBackground', "Background color behind folded ranges. The color must not be opaque so as not to hide underlying decorations."), true); registerColor('editorGutter.foldingControlForeground', { dark: iconForeground, light: iconForeground, hcDark: iconForeground, hcLight: iconForeground }, localize('editorGutter.foldingControlForeground', 'Color of the folding control in the editor gutter.')); </ins> export const foldingExpandedIcon = registerIcon('folding-expanded', Codicon.chevronDown, localize('foldingExpandedIcon', 'Icon for expanded ranges in the editor glyph margin.')); export const foldingCollapsedIcon = registerIcon('folding-collapsed', Codicon.chevronRight, localize('foldingCollapsedIcon', 'Icon for collapsed ranges in the editor glyph margin.')); export const foldingManualCollapsedIcon = registerIcon('folding-manual-collapsed', foldingCollapsedIcon, localize('foldingManualCollapedIcon', 'Icon for manually collapsed ranges in the editor glyph margin.')); export const foldingManualExpandedIcon = registerIcon('folding-manual-expanded', foldingExpandedIcon, localize('foldingManualExpandedIcon', 'Icon for manually expanded ranges in the editor glyph margin.')); <ins> const foldedBackgroundMinimap = { color: themeColorFromId(foldBackground), position: MinimapPosition.Inline }; </ins> export class FoldingDecorationProvider implements IDecorationProvider { private static readonly COLLAPSED_VISUAL_DECORATION = ModelDecorationOptions.register({


case FileOperation.DELETE: return await this._fireWillEvent(this._onWillDeleteFile, { files: files.map(f => URI.revive(f.target)) }, timeout, token); case FileOperation.CREATE: <ins> case FileOperation.COPY: </ins> return await this._fireWillEvent(this._onWillCreateFile, { files: files.map(f => URI.revive(f.target)) }, timeout, token); } return undefined;


} } export class PreviousMatchFindAction extends MatchFindAction { constructor() {


followsCaret?: boolean; ignoreCharChanges?: boolean; alwaysRevealFirst?: boolean; <ins> findResultLoop?: boolean; </ins> } const defaultOptions: Options = { followsCaret: true, ignoreCharChanges: true, <del> alwaysRevealFirst: true </del> <ins> alwaysRevealFirst: true, findResultLoop: true </ins> }; export interface IDiffNavigator {


type: 'boolean', default: typeof product.quality === 'string' && product.quality !== 'stable' // only enable as default in insiders }, <del> [NotebookSetting.cellExecutionScroll]: { markdownDescription: nls.localize('notebook.revealNextOnExecuteBehavior.description', "How far to scroll when revealing the next cell upon exectuting {0}.", 'notebook.cell.executeAndSelectBelow'), </del> <ins> [NotebookSetting.scrollToRevealCell]: { markdownDescription: nls.localize('notebook.scrolling.revealCellBehavior.description', "How far to scroll when revealing the selected, e.g. when exectuting {0}.", 'notebook.cell.executeAndSelectBelow'), </ins> type: 'string', enum: ['fullCell', 'firstLine', 'none'], markdownEnumDescriptions: [ <del> nls.localize('notebook.revealNextOnExecuteBehavior.fullCell.description', 'Scroll to fully reveal the next cell.'), nls.localize('notebook.revealNextOnExecuteBehavior.firstLine.description', 'Scroll to reveal the first line of the next cell.'), nls.localize('notebook.revealNextOnExecuteBehavior.nonedescription', 'Do not scroll to reveal the next cell.'), </del> <ins> nls.localize('notebook.scrolling.revealCellBehavior.fullCell.description', 'Scroll to fully reveal the selected cell.'), nls.localize('notebook.scrolling.revealCellBehavior.firstLine.description', 'Scroll to reveal the first line of the selected cell.'), nls.localize('notebook.scrolling.revealCellBehavior.nonedescription', 'Do not scroll to reveal the selected cell.'), </ins> ], default: 'fullCell' <ins> }, [NotebookSetting.anchorToFocusedCell]: { markdownDescription: nls.localize('notebook.scrolling.anchorToFocusedCell.description', "Keep the focused cell steady while surrounding cells change size"), type: 'string', enum: ['auto', 'true', 'false'], markdownEnumDescriptions: [ nls.localize('notebook.scrolling.anchorToFocusedCell.auto.description', "Anchor to the focused cell unless {0} is set to {1}", 'notebook.scrolling.revealCellBehavior', 'none') ], default: 'auto' </ins> } } });


private _lastLineRelativePosition: number = 0; private _hoverOnLine: number = -1; private _hoverOnColumn: number = -1; <ins> private _state: StickyScrollWidgetState | undefined; </ins> constructor( private readonly _editor: ICodeEditor


thanks.removeClass('task-panel-hidden'); } <del> yesButton.item(0).on('click', e => { </del> <ins> yesButton.on('click', e => { </ins> if (!this.storageService.get(this.taskExperimentPart5)) { this.telemetryService.publicLog('taskPanel.yes'); this.storageService.store(this.taskExperimentPart5, true, StorageScope.GLOBAL);


public createExtensionTerminal(options: vscode.ExtensionTerminalOptions, internalOptions?: ITerminalInternalOptions): vscode.Terminal { const terminal = new ExtHostTerminal(this._proxy, generateUuid(), options, options.name); const p = new ExtHostPseudoterminal(options.pty); <del> terminal.createExtensionTerminal(options.location, this._serializeParentTerminal(options, internalOptions).resolvedExtHostIdentifier, asTerminalIcon(options.iconPath), asTerminalColor(options.color)).then(id => { </del> <ins> terminal.createExtensionTerminal(options.location, internalOptions, this._serializeParentTerminal(options, internalOptions).resolvedExtHostIdentifier, asTerminalIcon(options.iconPath), asTerminalColor(options.color)).then(id => { </ins> const disposable = this._setupExtHostProcessListeners(id, p); this._terminalProcessDisposables[id] = disposable; });


registerAction2(OpenResultResource); registerAction2(SetMixedLayout); registerAction2(SetColumnLayout); <del> registerAction2(ShowHideBase); registerAction2(ShowHideAtTopBase); </del> registerAction2(OpenMergeEditor); registerAction2(OpenBaseFile); registerAction2(ShowNonConflictingChanges); <ins> registerAction2(ShowHideBase); registerAction2(ShowHideTopBase); registerAction2(ShowHideCenterBase); </ins> registerAction2(GoToNextUnhandledConflict); registerAction2(GoToPreviousUnhandledConflict);


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


if (this._xterm.getOption('disableStdin')) { this._attachPressAnyKeyToCloseListener(); } <ins> const neverMeasureRenderTime = this._storageService.getBoolean(NEVER_MEASURE_RENDER_TIME_STORAGE_KEY, StorageScope.GLOBAL, false); if (!neverMeasureRenderTime && this._configHelper.config.rendererType === 'auto') { this._measureRenderTime(); } </ins> }); } <ins> private _measureRenderTime(): void { const textRenderLayer = (<any>this._xterm).renderer._renderLayers[0]; const originalOnGridChanged = textRenderLayer.onGridChanged; textRenderLayer.onGridChanged = (terminal: XTermTerminal, firstRow: number, lastRow: number) => { const startTime = performance.now(); originalOnGridChanged.call(textRenderLayer, terminal, firstRow, lastRow); const renderTimeMilliseconds = performance.now() - startTime; if (renderTimeMilliseconds > SLOW_CANVAS_RENDER_THRESHOLD) { const promptChoices: IPromptChoice[] = [ { label: nls.localize('yes', "Yes"), run: () => { this._configurationService.updateValue('terminal.integrated.rendererType', 'dom', ConfigurationTarget.USER).then(() => { this._notificationService.info(nls.localize('terminal.rendererInAllNewTerminals', "All newly created terminals will use the non-GPU renderer.")); }); } } as IPromptChoice, { label: nls.localize('no', "No") } as IPromptChoice, { label: nls.localize('dontShowAgain', "Don't Show Again"), isSecondary: true, run: () => this._storageService.store(NEVER_MEASURE_RENDER_TIME_STORAGE_KEY, true) } as IPromptChoice ]; this._notificationService.prompt( Severity.Warning, nls.localize('terminal.slowRendering', 'The current standard canvas renderer for the integrated terminal appears to be slow on your computer. Using the DOM-based renderer may improve performance, do you want to switch to the DOM-based renderer? [Read more about terminal settings](https://code.visualstudio.com/docs/editor/integrated-terminal#_changing-how-the-terminal-is-rendered).'), promptChoices ); } // Restore original function textRenderLayer.onGridChanged = originalOnGridChanged; }; } </ins> public registerLinkMatcher(regex: RegExp, handler: (url: string) => void, matchIndex?: number, validationCallback?: (uri: string, callback: (isValid: boolean) => void) => void): number { return this._linkHandler.registerCustomLinkHandler(regex, handler, matchIndex, validationCallback); }


} async delete(item: ITrustedUriItem) { <ins> this.table.focusNext(); </ins> await this.workspaceTrustManagementService.setUrisTrust([item.uri], false); <ins> if (this.table.getFocus().length === 0) { this.table.focusLast(); } </ins> this._onDelete.fire(item); <ins> this.table.domFocus(); </ins> } async edit(item: ITrustedUriItem, usePickerIfPossible?: boolean) {


declare namespace monaco { <ins> // THIS IS A GENERATED FILE. DO NOT EDIT DIRECTLY. </ins> export type Thenable<T> = PromiseLike<T>; export interface IDisposable {


overviewRulerLanes: IEditorOption<EditorOption.overviewRulerLanes, number>; parameterHints: IEditorOption<EditorOption.parameterHints, InternalParameterHintOptions>; peekWidgetDefaultFocus: IEditorOption<EditorOption.peekWidgetDefaultFocus, 'tree' | 'editor'>; <ins> definitionLinkOpensInPeek: IEditorOption<EditorOption.definitionLinkOpensInPeek, boolean>; </ins> quickSuggestions: IEditorOption<EditorOption.quickSuggestions, ValidQuickSuggestionsOptions>; quickSuggestionsDelay: IEditorOption<EditorOption.quickSuggestionsDelay, number>; readOnly: IEditorOption<EditorOption.readOnly, boolean>;


"name": "Markup Headings", "scope": "markup.heading", "settings": { <ins> "fontStyle": "bold", </ins> "foreground": "#268BD2" } },


private launchJsonChanged: boolean; private firstSessionStart: boolean; private previousState: debug.State; <ins> private fetchThreadsSchedulers: Map<string, RunOnceScheduler>; </ins> constructor( @IStorageService private storageService: IStorageService,


import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService'; import { mainWindow } from 'vs/base/browser/window'; import { TestCodeEditorService } from 'vs/editor/test/browser/editorTestServices'; <del> import { IInlineChatService } from 'vs/workbench/contrib/inlineChat/common/inlineChat'; import { InlineChatServiceImpl } from 'vs/workbench/contrib/inlineChat/common/inlineChatServiceImpl'; </del> import { INotebookCellOutlineProviderFactory, NotebookCellOutlineProviderFactory } from 'vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineProviderFactory'; import { ILanguageDetectionService } from 'vs/workbench/services/languageDetection/common/languageDetectionWorkerService';


"editorGutter.deletedBackground": "#f85149", "editorGutter.modifiedBackground": "#005FB8", "editorIndentGuide.background": "#D3D3D3", <del> "editorInlayHint.background": "#8b949e33", "editorInlayHint.foreground": "#8b949e", "editorInlayHint.typeBackground": "#8b949e33", "editorInlayHint.typeForeground": "#8b949e", </del> <ins> "editorInlayHint.background": "#8b949e1b", "editorInlayHint.typeBackground": "#8b949e1b", </ins> "editorLineNumber.activeForeground": "#171184", "editorLineNumber.foreground": "#6e7681", "editorOverviewRuler.border": "#0000001a",


this.setInput(input); this.disposables.push(this.onDidChangeSelection(event => { <del> extensionsWorkdbenchService.open(event.elements[0], event.browserEvent instanceof MouseEvent && (event.browserEvent.ctrlKey || event.browserEvent.metaKey || event.browserEvent.altKey)); </del> <ins> if (event.browserEvent && event.browserEvent instanceof KeyboardEvent) { extensionsWorkdbenchService.open(event.elements[0].extension, false); } </ins> })); } }  No newline at end of file


private resetCenteredEditor(layout: boolean = true) { this.centeredEditorLeftMarginRatio = 0.5; <del> this.centeredEditorPreferedSize = Math.floor(this.dimension.width * EditorGroupsControl.GOLDEN_RATIO); </del> <ins> this.centeredEditorPreferredSize = Math.floor(this.dimension.width * EditorGroupsControl.GOLDEN_RATIO); </ins> if (layout) { this.layoutContainers(); } <del> this.storageServise.remove(EditorGroupsControl.CENTERED_EDITOR_LAYOUT_DATA_STORAGE_KEY, StorageScope.GLOBAL); </del> <ins> this.storageService.remove(EditorGroupsControl.CENTERED_EDITOR_LAYOUT_DATA_STORAGE_KEY, StorageScope.GLOBAL); </ins> } public getInstantiationService(position: Position): IInstantiationService {


description: nls.localize('search.globalFindClipboard', "Controls whether the search view should read or modify the shared find clipboard on macOS."), included: platform.isMacintosh }, <ins> 'search.location': { type: 'string', enum: ['sidebar', 'panel'], default: 'sidebar', description: nls.localize('search.location', "Controls whether the search will be shown as a view in the sidebar or as a panel in the panel area for more horizontal space."), deprecationMessage: nls.localize('search.location.deprecationMessage', "This setting is deprecated. Please use the search view's context menu instead.") }, </ins> 'search.collapseResults': { type: 'string', enum: ['auto', 'alwaysCollapse', 'alwaysExpand'],


execution_count: cell.executionSummary?.executionOrder ?? null, source: splitMultilineString(cell.value.replace(/rn/g, 'n')), outputs: (cell.outputs || []).map(translateCellDisplayOutput), <del> metadata: metadata </del> <ins> metadata: cellMetadata.metadata </ins> }; if (cellMetadata?.id) { codeCell.id = cellMetadata.id;


if (editorHighlighterContrib.wordHighlighter.decorations.length > 0) { editorHighlighterContrib.wordHighlighter.decorations.clear(); <ins> editorHighlighterContrib.wordHighlighter.workerRequest = null; </ins> editorHighlighterContrib.wordHighlighter._hasWordHighlights.set(false); } }


return true; } <del> if (!this._initialized) { return false; </del> <ins> if (this.environmentService.extensionTestsLocationURI) { return true; // trust running tests with vscode-test </ins> } // Remote - remote authority explicitly sets workspace trust


label: markActiveWhen(currentSecurityLevel === MarkdownPreviewSecurityLevel.Strict) + localize('strict.title', 'Strict'), description: localize('strict.description', 'Only load secure content'), }, { <ins> type: MarkdownPreviewSecurityLevel.AllowInsecureLocalContent, label: markActiveWhen(currentSecurityLevel === MarkdownPreviewSecurityLevel.AllowInsecureLocalContent) + localize('insecureLocalContent.title', 'Allow insecure local content'), description: localize('insecureLocalContent.description', 'Enable loading content over http served from localhost'), }, { </ins> type: MarkdownPreviewSecurityLevel.AllowInsecureContent, label: markActiveWhen(currentSecurityLevel === MarkdownPreviewSecurityLevel.AllowInsecureContent) + localize('insecureContent.title', 'Allow insecure content'), description: localize('insecureContent.description', 'Enable loading content over http'),


} if (size > 3 * this.minSize && size < this.centeredEditorAvailableSize) { <del> this.centeredEditorPreferedSize = size; </del> <ins> this.centeredEditorPreferredSize = size; </ins> position -= EditorGroupsControl.CENTERED_EDITOR_MIN_MARGIN; position = Math.min(position, this.centeredEditorAvailableSize - this.centeredEditorSize); position = Math.max(0, position);


); // Apply extension environment variable collections to the environment <del> if (!shellLaunchConfig.strictEnv) { </del> <ins> if (shouldUseEnvironmentVariableCollection(shellLaunchConfig)) { </ins> const entries: [string, IEnvironmentVariableCollection][] = []; for (const [k, v, d] of args.envVariableCollections) { entries.push([k, { map: deserializeEnvironmentVariableCollection(v), descriptionMap: deserializeEnvironmentDescriptionMap(d) }]);


this._cursorBlinking = options.get(EditorOption.cursorBlinking); this._cursorStyle = options.get(EditorOption.cursorStyle); this._cursorSmoothCaretAnimation = options.get(EditorOption.cursorSmoothCaretAnimation); <ins> this._experimentalEditContextEnabled = options.get(EditorOption.experimentalEditContextEnabled); </ins> this._selectionIsEmpty = true; this._isComposingInput = false;


if (url.authority) { this._url = this.urlOrCommand; } else { <del> const urlCommand: Promise<string | undefined> = this.commandService.executeCommand(this.urlOrCommand); </del> <ins> const urlCommand: Promise<string | undefined> = this.commandService.executeCommand(this.urlOrCommand).then((result) => { // if executing this command times out, cache its value whenever it eventually resolves this._url = result; return this._url; }); </ins> // We must be defensive. The command may never return, meaning that no help at all is ever shown! const emptyString: Promise<string> = new Promise(resolve => setTimeout(() => resolve(''), 500)); this._url = await Promise.race([urlCommand, emptyString]);


let resolverData: Map<string, ResolverData> | undefined; <del> async function quickResolve(that: AbstractTaskService, identifier: string | TaskIdentifier) { </del> <ins> async function quickResolve(that: AbstractTaskService, uri: URI | string, identifier: string | TaskIdentifier) { </ins> const foundTasks = await that._findWorkspaceTasks((task: Task | ConfiguringTask): boolean => { <ins> const taskUri = ((ConfiguringTask.is(task) || CustomTask.is(task)) ? task._source.config.workspaceFolder?.uri : undefined); const originalUri = (typeof uri === 'string' ? uri : uri.toString()); if (taskUri?.toString() !== originalUri) { return false; } </ins> if (Types.isString(identifier)) { return ((task._label === identifier) || (task.configurationProperties.identifier === identifier)); } else {


stickiness: TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges, afterContentClassName: 'inline-folded', isWholeLine: true, <del> firstLineDecorationClassName: ThemeIcon.asClassName(foldingCollapsedIcon) </del> <ins> firstLineDecorationClassName: ThemeIcon.asClassName(foldingCollapsedIcon), </ins> }); private static readonly COLLAPSED_HIGHLIGHTED_VISUAL_DECORATION = ModelDecorationOptions.register({


// Group editors count context groupEditorsCountContext.set(this.count); <del> })); </del> <ins> }; this._register(this.onDidModelChange(e => updateGroupContextKeys(e))); </ins> // Track the active editor and update context key that reflects // the dirty state of this editor <del> this._register(this.onDidActiveEditorChange(() => { observeActiveEditor(); })); </del> <ins> this._register(this.onDidActiveEditorChange(() => observeActiveEditor())); </ins> // Update context keys on startup observeActiveEditor(); <ins> updateGroupContextKeys({ kind: GroupModelChangeKind.EDITOR_ACTIVE }); updateGroupContextKeys({ kind: GroupModelChangeKind.GROUP_LOCKED }); </ins> } private registerContainerListeners(): void {


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


import { IObservableValue, MutableObservableValue, staticObservableValue } from 'vs/workbench/contrib/testing/common/observableValue'; import { IRichLocation, ISerializedTestResults, ITestItem, ITestMessage, ITestOutputMessage, ITestRunTask, ITestTaskState, ResolvedTestRunRequest, TestItemExpandState, TestMessageType, TestResultItem, TestResultState } from 'vs/workbench/contrib/testing/common/testCollection'; import { TestCoverage } from 'vs/workbench/contrib/testing/common/testCoverage'; <del> import { maxPriority, statesInOrder } from 'vs/workbench/contrib/testing/common/testingStates'; </del> <ins> import { maxPriority, statesInOrder, terminalStatePriorities } from 'vs/workbench/contrib/testing/common/testingStates'; </ins> export interface ITestRunTaskResults extends ITestRunTask { /**


resource: symbolToOpen.location.uri, options: { preserveFocus: options?.preserveFocus, <del> pinned: options.keyMods.alt || this.configuration.openEditorPinned, </del> <ins> pinned: options.keyMods.alt || options.forcePinned || this.configuration.openEditorPinned, </ins> selection: symbolToOpen.location.range ? Range.collapseToStart(symbolToOpen.location.range) : undefined } }, options.keyMods.ctrlCmd || options?.forceOpenSideBySide ? SIDE_GROUP : ACTIVE_GROUP);


document.body.classList.remove('loading'); }); <del> image.src = decodeURI(settings.src); </del> <ins> image.src = settings.src; </ins> window.addEventListener('message', e => { switch (e.data.type) {


notificationService.prompt(Severity.Info, localize('configuringURL', "Configuring trust for: {0}", resource.toString()), [{ label: 'Copy', run: () => clipboardService.writeText(resource.toString()) }]); return trustedDomains; <del> case 'trustDomain': case 'trustSubdomain': case 'trustAll': const itemToTrust = pickedResult.id === 'trustDomain' ? domainToConfigure : pickedResult.id === 'trustSubdomain' ? topLevelDomain : '*'; </del> <ins> case 'trust': const itemToTrust = pickedResult.toTrust; </ins> if (trustedDomains.indexOf(itemToTrust) === -1) { storageService.remove(TRUSTED_DOMAINS_CONTENT_STORAGE_KEY, StorageScope.GLOBAL); storageService.store(


'application/x.notebook.stream', 'application/vnd.code.notebook.stderr', 'application/x.notebook.stderr', <del> 'text/plain' </del> <ins> 'text/plain', 'text/markdown', 'application/json' </ins> ];


import { EditorOption } from 'vs/editor/common/config/editorOptions'; import * as dom from 'vs/base/browser/dom'; import { hash } from 'vs/base/common/hash'; <ins> import { IQuickInputService, IQuickPickItem, IQuickPickSeparator } from 'vs/platform/quickinput/common/quickInput'; </ins> export class CodeLensContribution implements IEditorContribution {


import { TerminalInitialHintSettingId } from 'vs/workbench/contrib/terminalContrib/chat/common/terminalInitialHintConfiguration'; import { ChatAgentLocation, IChatAgent, IChatAgentService } from 'vs/workbench/contrib/chat/common/chatAgents'; import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage'; <ins> import { IContextMenuService } from 'vs/platform/contextview/browser/contextView'; import { StandardMouseEvent } from 'vs/base/browser/mouseEvent'; </ins> const $ = dom.$;


this._keyListener = this._register(this._editorWidget.onKeyUp((e) => { if (e.keyCode === KeyCode.Escape) { this._contextViewService.hideContextView(); <ins> // Delay to allow the context view to hide #186514 setTimeout(() => provider.onClose(), 100); this._keyListener?.dispose(); </ins> } else if (e.keyCode === KeyCode.KeyD && this._configurationService.getValue(settingKey)) { this._configurationService.updateValue(settingKey, false); } else if (e.keyCode === KeyCode.KeyH && provider.options.readMoreUrl) {


//TODO: update progress in a newly inserted cell below the widget instead of the fake editor <del> const requestCts = new CancellationTokenSource(); </del> <ins> this._activeRequestCts?.cancel(); this._activeRequestCts = new CancellationTokenSource(); </ins> const progressEdits: TextEdit[][] = []; const progressiveEditsQueue = new Queue(); const progressiveEditsClock = StopWatch.create(); const progressiveEditsAvgDuration = new MovingAverage(); <del> const progressiveEditsCts = new CancellationTokenSource(requestCts.token); </del> <ins> const progressiveEditsCts = new CancellationTokenSource(this._activeRequestCts.token); </ins> let progressiveChatResponse: IInlineChatMessageAppender | undefined; const progress = new AsyncProgress<IInlineChatProgressItem>(async data => { // console.log('received chunk', data, request); <del> if (requestCts.token.isCancellationRequested) { </del> <ins> if (this._activeRequestCts?.token.isCancellationRequested) { </ins> return; }


border-width: 0 !important; } <ins> .action-widget .monaco-list:focus:before { outline: 0 !important; } </ins> .action-widget .monaco-list .monaco-scrollable-element .monaco-list-rows { height: 100% !important; }


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


} if (!this.storeClient) { <del> this.storeClient = new UserDataSyncStoreClient(URI.parse(this.serverConfiguration.url), this.productService, this.requestService, this.logService, this.environmentService, this.fileService, this.storageService); </del> <ins> this.storeClient = new EditSessionsStoreClient(URI.parse(this.serverConfiguration.url), this.productService, this.requestService, this.logService, this.environmentService, this.fileService, this.storageService); </ins> this._register(this.storeClient.onTokenFailed(() => { this.logService.info('Clearing edit sessions authentication preference because of successive token failures.'); this.clearAuthenticationPreference(); })); } <ins> if (this.machineClient === undefined) { this.machineClient = new UserDataSyncMachinesService(this.environmentService, this.fileService, this.storageService, this.storeClient!, this.logService, this.productService); } </ins> // If we already have an existing auth session in memory, use that if (this.#authenticationInfo !== undefined) { return true;


container.style.borderColor = borderColor ? borderColor : ''; } <del> show(): void { </del> <ins> show(focus?: boolean): void { </ins> if (!this.content) { return; } <del> if (this.compositeBar.value) { return; } </del> <ins> if (!this.compositeBar.value) { this.compositeBar.value = this.createCompositeBar(); this.compositeBar.value.create(this.content); </ins> <del> this.compositeBar.value = this.createCompositeBar(); this.compositeBar.value.create(this.content); </del> <ins> if (this.dimension) { this.layout(this.dimension.width, this.dimension.height); } } </ins> <del> if (this.dimension) { this.layout(this.dimension.width, this.dimension.height); </del> <ins> if (focus) { this.focus(); </ins> } }


resolved "https://registry.yarnpkg.com/vscode-textmate/-/vscode-textmate-9.0.0.tgz#313c6c8792b0507aef35aeb81b6b370b37c44d6c" integrity sha512-Cl65diFGxz7gpwbav10HqiY/eVYTO1sjQpmRmV991Bj7wAoOAjGQ97PpQcXorDE2Uc4hnGWLY17xme+5t6MlSg== <del> xterm-addon-canvas@0.4.0-beta.7: version "0.4.0-beta.7" resolved "https://registry.yarnpkg.com/xterm-addon-canvas/-/xterm-addon-canvas-0.4.0-beta.7.tgz#ae365d8e10c900292186529f70f7f275ac94b3d5" integrity sha512-r1hbQTsulI49orR5G3qWrJCwn2dKsEUCrgj6xsmgXuTeoUcGfed6lly+MvYlL3P8aPrxS2fC2TEzSM0Au4SX+w== </del> <ins> xterm-addon-canvas@0.4.0-beta.9: version "0.4.0-beta.9" resolved "https://registry.yarnpkg.com/xterm-addon-canvas/-/xterm-addon-canvas-0.4.0-beta.9.tgz#e570fa4592890f92cc86706f2bba0dd128a8641d" integrity sha512-BWRVWyUW7NY2g4BBMm3ecPQvbdyKXFgABnpmh4m0TVHqFJMNeXdNuTc94KiDbE+cvw8jtAY9NC/OIM4HcgjAIQ== </ins> xterm-addon-search@0.11.0: version "0.11.0"


} } <del> export class ShowHideAtTopBase extends Action2 { </del> <ins> export class ShowHideTopBase extends Action2 { </ins> constructor() { super({ <del> id: 'merge.showBaseAtTop', </del> <ins> id: 'merge.showBaseTop', </ins> title: { <del> value: localize('layout.showBaseAtTop', 'Show Base At Top'), original: 'Show Base At Top', </del> <ins> value: localize('layout.showBaseTop', 'Show Base Top'), original: 'Show Base Top', </ins> }, <del> toggled: ctxMergeEditorShowBaseAtTop.isEqualTo(true), </del> <ins> toggled: ContextKeyExpr.and(ctxMergeEditorShowBase, ctxMergeEditorShowBaseAtTop), </ins> menu: [ { id: MenuId.EditorTitle, <del> when: ctxIsMergeEditor, </del> <ins> when: ContextKeyExpr.and(ctxIsMergeEditor, ctxMergeEditorLayout.isEqualTo('mixed')), </ins> group: '2_merge', order: 10, }, ], <del> precondition: ContextKeyExpr.and(ctxIsMergeEditor, ctxMergeEditorShowBase, ctxMergeEditorLayout.isEqualTo('mixed')), </del> }); } run(accessor: ServicesAccessor): void { const { activeEditorPane } = accessor.get(IEditorService); if (activeEditorPane instanceof MergeEditor) { <del> activeEditorPane.toggleShowBaseAtTop(); </del> <ins> activeEditorPane.toggleShowBaseTop(); } } } export class ShowHideCenterBase extends Action2 { constructor() { super({ id: 'merge.showBaseCenter', title: { value: localize('layout.showBaseCenter', 'Show Base Center'), original: 'Show Base Center', }, toggled: ContextKeyExpr.and(ctxMergeEditorShowBase, ctxMergeEditorShowBaseAtTop.negate()), menu: [ { id: MenuId.EditorTitle, when: ContextKeyExpr.and(ctxIsMergeEditor, ctxMergeEditorLayout.isEqualTo('mixed')), group: '2_merge', order: 11, }, ], }); } run(accessor: ServicesAccessor): void { const { activeEditorPane } = accessor.get(IEditorService); if (activeEditorPane instanceof MergeEditor) { activeEditorPane.toggleShowBaseCenter(); </ins> } } }


return this._remoteTerminalChannel.setTerminalLayoutInfo(layout); } <del> public getTerminalLayoutInfo(): Promise<ITerminalsLayoutInfo | undefined> { </del> <ins> public async getTerminalLayoutInfo(): Promise<ITerminalsLayoutInfo | undefined> { await this._remoteTerminalChannel?.listProcesses(true); </ins> if (!this._remoteTerminalChannel) { throw new Error(`Cannot call getActiveInstanceId when there is no remote`); }


resolved "https://registry.yarnpkg.com/@types/mdurl/-/mdurl-1.0.2.tgz#e2ce9d83a613bacf284c7be7d491945e39e1f8e9" integrity sha512-eC4U9MlIcu2q0KQmXszyn5Akca/0jrQmwDRgpAMJai7qBWq4amIQhZyNau4VYGtCeALvW1/NtjzJJ567aZxfKA== <del> "@types/uuid@^8.3.1": version "8.3.4" resolved "https://registry.yarnpkg.com/@types/uuid/-/uuid-8.3.4.tgz#bd86a43617df0594787d38b735f55c805becf1bc" integrity sha512-c/I8ZRb51j+pYGAu5CrFMRxqZ2ke4y2grEBO5AUjgSkSk+qT2Ea+OdWElz/OiMf5MNpn2b17kuVBwZLQJXzihw== </del> detect-indent@^6.0.0: version "6.1.0" resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-6.1.0.tgz#592485ebbbf6b3b1ab2be175c8393d04ca0d57e6" integrity sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA== <del> uuid@^8.3.2: version "8.3.2" resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.3.2.tgz#80d5b5ced271bb9af6c445f21a1a04c606cefbe2" integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg== </del>


return; } <ins> if (e.browserEvent.defaultPrevented) { return; } </ins> const focus = e.index; if (typeof focus === 'undefined') {


} private _getIcon(): TerminalIcon | undefined { <del> const icon = this._shellLaunchConfig.icon || this._shellLaunchConfig.attachPersistentProcess?.icon; if (!icon) { return this._processManager.processState >= ProcessState.Launching ? Codicon.terminal : undefined; </del> <ins> if (!this._icon) { this._icon = this._processManager.processState >= ProcessState.Launching ? Codicon.terminal : undefined; </ins> } <del> return icon; </del> <ins> return this._icon; </ins> } private _getColor(): string | undefined {


reviveBuffer: string | undefined, private _icon?: TerminalIcon, private _color?: string, <ins> name?: string, </ins> fixedDimensions?: IFixedTerminalDimensions ) { super(); <ins> if (name) { this.setTitle(name, TitleEventSource.Api); } </ins> this._logService.trace('persistentTerminalProcess#ctor', _persistentProcessId, arguments); this._wasRevived = reviveBuffer !== undefined; this._serializer = new XtermSerializer(


<ins> <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <plist version="1.0"> <dict> <key>fileTypes</key> <array> <string>ini</string> <string>INI</string> <string>inf</string> <string>INF</string> <string>reg</string> <string>REG</string> <string>lng</string> <string>cfg</string> <string>CFG</string> <string>url</string> <string>URL</string> <string>.editorconfig</string> </array> <key>name</key> <string>INI</string> <key>patterns</key> <array> <dict> <key>captures</key> <dict> <key>1</key> <dict> <key>name</key> <string>punctuation.definition.comment.ini</string> </dict> </dict> <key>match</key> <string>^s*(;|#).*$n?</string> <key>name</key> <string>comment.line.semicolon.ini</string> </dict> <dict> <key>captures</key> <dict> <key>1</key> <dict> <key>name</key> <string>punctuation.definition.section.ini</string> </dict> <key>2</key> <dict> <key>name</key> <string>entity.section.ini</string> </dict> <key>3</key> <dict> <key>name</key> <string>punctuation.definition.section.ini</string> </dict> </dict> <key>match</key> <string>^s*([)(.*?)(])</string> <key>name</key> <string>meta.tag.section.ini</string> </dict> <dict> <key>captures</key> <dict> <key>1</key> <dict> <key>name</key> <string>meta.property.ini</string> </dict> <key>2</key> <dict> <key>name</key> <string>punctuation.definition.quote.ini</string> </dict> <key>3</key> <dict> <key>name</key> <string>keyword.name.ini</string> </dict> <key>4</key> <dict> <key>name</key> <string>punctuation.definition.quote.ini</string> </dict> <key>5</key> <dict> <key>name</key> <string>punctuation.definition.equals.ini</string> </dict> <key>6</key> <dict> <key>name</key> <string>meta.value.ini</string> </dict> <key>7</key> <dict> <key>name</key> <string>punctuation.definition.quote.ini</string> </dict> <key>8</key> <dict> <key>name</key> <string>string.name.value.ini</string> </dict> <key>9</key> <dict> <key>name</key> <string>punctuation.definition.quote.ini</string> </dict> <key>10</key> <dict> <key>name</key> <string>comment.declarationline.semicolon.ini</string> </dict> </dict> <key>match</key> <string>^(s*(["']?)(.+?)(2)s*(=))?s*((["']?)(.*?)(7))s*(;.*)?$n?</string> <key>name</key> <string>meta.declaration.ini</string> </dict> </array> <key>scopeName</key> <string>source.ini</string> <key>uuid</key> <string>957acd74-6d7c-4732-a25b-5f66a1e637cd</string> </dict> </plist> </ins>


@IPartService partService: IPartService, @IKeybindingService keybindingService: IKeybindingService, @IInstantiationService instantiationService: IInstantiationService, <del> @IThemeService themeService: IThemeService </del> <ins> @IThemeService themeService: IThemeService, @IContextKeyService contextKeyService: IContextKeyService, </ins> ) { super( notificationService,


registerEditorContribution(MarkerController); registerEditorAction(NextMarkerAction); registerEditorAction(PrevMarkerAction); <ins> registerEditorAction(NextMarkerInFilesAction); registerEditorAction(PrevMarkerInFilesAction); </ins> const CONTEXT_MARKERS_NAVIGATION_VISIBLE = new RawContextKey<boolean>('markersNavigationVisible', false);


const keybindingService = accessor.get(IKeybindingService); const contextKeyService = accessor.get(IContextKeyService); <del> const next = keybindingService.lookupKeybinding(AccessibleDiffViewerNext.id)?.getAriaLabel(); const previous = keybindingService.lookupKeybinding(AccessibleDiffViewerPrev.id)?.getAriaLabel(); </del> if (!(editorService.activeTextEditorControl instanceof DiffEditorWidget)) { return; }


let debugKeybindingLabel = ''; viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, { <del> content: localize( { key: 'runAndDebugAction', comment: [ '{0} will be replaced with a keybinding', 'Please do not translate the word "command", it is part of our internal syntax which must not change', '{Locked="](command:{1})"}' ] }, "[Run and Debug{0}](command:{1})", debugKeybindingLabel, DEBUG_START_COMMAND_ID), </del> <ins> content: `[${localize('runAndDebugAction', "Run and Debug")}${debugKeybindingLabel}](command:${DEBUG_START_COMMAND_ID})`, </ins> when: CONTEXT_DEBUGGERS_AVAILABLE, group: ViewContentGroups.Debug, // Allow inserting more buttons directly after this one (by setting order to 1).


"vscode-proxy-agent": "^0.12.0", "vscode-regexpp": "^3.1.0", "vscode-textmate": "7.0.1", <del> "xterm": "5.0.0-beta.32", "xterm-addon-canvas": "0.2.0-beta.15", "xterm-addon-search": "0.10.0-beta.3", "xterm-addon-serialize": "0.8.0-beta.3", "xterm-addon-unicode11": "0.4.0-beta.3", "xterm-addon-webgl": "0.13.0-beta.32", </del> <ins> "xterm": "5.0.0-beta.35", "xterm-addon-canvas": "0.2.0-beta.17", "xterm-addon-search": "0.10.0-beta.5", "xterm-addon-serialize": "0.8.0-beta.5", "xterm-addon-unicode11": "0.4.0-beta.5", "xterm-addon-webgl": "0.13.0-beta.35", </ins> "xterm-headless": "5.0.0-beta.5", "yauzl": "^2.9.2", "yazl": "^2.4.3"


return undefined; } if ((resolverData === undefined) && (grouped === undefined)) { <del> return (await quickResolve(this, identifier)) ?? fullResolve(this, uri, identifier); </del> <ins> return (await quickResolve(this, uri, identifier)) ?? fullResolve(this, uri, identifier); </ins> } else { return fullResolve(this, uri, identifier); }


private readonly _onDidChangeVisibility = this._register(new Emitter<boolean>()); readonly onDidChangeVisibility = this._onDidChangeVisibility.event; <ins> private readonly _onWillPaste = this._register(new Emitter<string>()); readonly onWillPaste = this._onWillPaste.event; private readonly _onDidPaste = this._register(new Emitter<string>()); readonly onDidPaste = this._onDidPaste.event; </ins> constructor( private readonly _terminalShellTypeContextKey: IContextKey<string>, private readonly _terminalInRunCommandPicker: IContextKey<boolean>,


@IChatService chatService: IChatService, @IHoverService hoverService: IHoverService, ) { <del> super(location, { ...options, chatWidgetViewOptions: { editorOverflowWidgetsDomNode: _parentEditor.getOverflowWidgetsDomNode() } }, instantiationService, contextKeyService, keybindingService, accessibilityService, configurationService, accessibleViewService, textModelResolverService, chatService, hoverService); </del> <ins> super(location, { ...options, chatWidgetViewOptions: { ...options.chatWidgetViewOptions, editorOverflowWidgetsDomNode: _parentEditor.getOverflowWidgetsDomNode() } }, instantiationService, contextKeyService, keybindingService, accessibilityService, configurationService, accessibleViewService, textModelResolverService, chatService, hoverService); </ins> } // --- layout


export async function pickRemoteSource(model: Model, options: PickRemoteSourceOptions & { branch: true }): Promise<PickRemoteSourceResult | undefined>; export async function pickRemoteSource(model: Model, options: PickRemoteSourceOptions = {}): Promise<string | PickRemoteSourceResult | undefined> { const quickpick = window.createQuickPick<(QuickPickItem & { provider?: RemoteSourceProvider; url?: string })>(); <del> quickpick.ignoreFocusOut = true; </del> quickpick.title = options.title; if (options.providerName) {


this._register(this.remoteExplorerService.onEnabledPortsFeatures(() => this._proxy.$registerCandidateFinder(this.processFindingEnabled()))); } this._register(this.configurationService.onDidChangeConfiguration(async (e) => { <del> if (e.affectsConfiguration(PORT_AUTO_FORWARD_SETTING) || e.affectsConfiguration(PORT_AUTO_SOURCE_SETTING)) { </del> <ins> if (this.remoteExplorerService.portsFeaturesEnabled && (e.affectsConfiguration(PORT_AUTO_FORWARD_SETTING) || e.affectsConfiguration(PORT_AUTO_SOURCE_SETTING))) { </ins> return this._proxy.$registerCandidateFinder(this.processFindingEnabled()); } })); <del> this._register(this.tunnelService.onAddedTunnelProvider(() => { return this._proxy.$registerCandidateFinder(this.processFindingEnabled()); </del> <ins> this._register(this.tunnelService.onAddedTunnelProvider(async () => { if (this.remoteExplorerService.portsFeaturesEnabled) { return this._proxy.$registerCandidateFinder(this.processFindingEnabled()); } </ins> })); }


} try { <del> return super.write(resource, value, options); </del> <ins> return await super.write(resource, value, options); </ins> } catch (error) { // In case of permission denied, we need to check for readonly


if (seenVersions.has(version.version)) { return; } <del> seenVersions.add(version.version); </del> if (await this.isValidVersion(version, preRelease ? 'prerelease' : 'release', true, allTargetPlatforms, targetPlatform)) { result.push({ version: version.version, date: version.lastUpdated, isPreReleaseVersion: isPreReleaseVersion(version) }); <ins> seenVersions.add(version.version); </ins> } } catch (error) { /* Ignore error and skip version */ } }));


* or via Size to Content Width */ fixedDimensions?: IFixedTerminalDimensions; <ins> /** * Opt-out of the default terminal persistence on restart and reload */ disablePersistence?: boolean; </ins> } export interface ICreateContributedTerminalProfileOptions {


"list.activeSelectionBackground": "#707070", "list.focusBackground": "#707070", "list.inactiveSelectionBackground": "#4e4e4e", <del> "list.hoverBackground": "#707070", </del> <ins> "list.hoverBackground": "#444444", </ins> "list.highlightForeground": "#e58520", "button.background": "#565656", "editor.background": "#1e1e1e",


osx: string[]; windows: string[]; }; <ins> altClickMovesCursor: boolean; </ins> macOptionIsMeta: boolean; macOptionClickForcesSelection: boolean; rendererType: 'auto' | 'canvas' | 'dom' | 'experimentalWebgl';


import { INotificationService } from 'vs/platform/notification/common/notification'; import { ILogService } from 'vs/platform/log/common/log'; import { basename } from 'vs/base/common/path'; <del> import { IWorkingCopyService, IWorkingCopyBackup } from 'vs/workbench/services/workingCopy/common/workingCopyService'; </del> <ins> import { IWorkingCopyService, IWorkingCopyBackup, WorkingCopyCapabilities } from 'vs/workbench/services/workingCopy/common/workingCopyService'; </ins> import { IFilesConfigurationService } from 'vs/workbench/services/filesConfiguration/common/filesConfigurationService'; import { ILabelService } from 'vs/platform/label/common/label'; import { CancellationTokenSource } from 'vs/base/common/cancellation';


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


import { deepClone } from 'vs/base/common/objects'; import { isObject, assertIsDefined, withUndefinedAsNull, withNullAsUndefined } from 'vs/base/common/types'; import { ICodeEditor, IDiffEditor } from 'vs/editor/browser/editorBrowser'; <del> import { IDiffEditorOptions, IEditorOptions as ICodeEditorOptions } from 'vs/editor/common/config/editorOptions'; </del> <ins> import { IDiffEditorOptions, EditorOption, IEditorOptions as ICodeEditorOptions } from 'vs/editor/common/config/editorOptions'; </ins> import { AbstractTextEditor, IEditorConfiguration } from 'vs/workbench/browser/parts/editor/textEditor'; import { TEXT_DIFF_EDITOR_ID, IEditorFactoryRegistry, EditorExtensions, ITextDiffEditorPane, IEditorOpenContext, EditorInputCapabilities, isEditorInput, isTextEditorViewState } from 'vs/workbench/common/editor'; import { EditorInput } from 'vs/workbench/common/editor/editorInput';


override async show(initialInput?: string, options?: IShowNotebookFindWidgetOptions): Promise<void> { const searchStringUpdate = this._state.searchString !== initialInput; super.show(initialInput, options); <del> this._state.change({ searchString: initialInput ?? '', isRevealed: true }, false); </del> <ins> this._state.change({ searchString: initialInput ?? this._state.searchString, isRevealed: true }, false); </ins> if (typeof options?.matchIndex === 'number') { if (!this._findModel.findMatches.length) {


}); inputBox.onDidHide(() => { <ins> this.clearDecorations(editor); </ins> inputBox.dispose(); }); inputBox.show(); } <ins> private clearDecorations(editor: ICodeEditor): void { editor.changeDecorations(changeAccessor => { this._highlightDecorations = changeAccessor.deltaDecorations(this._highlightDecorations, []); }); } private addDecorations(editor: ICodeEditor, range: IRange): void { editor.changeDecorations(changeAccessor => { this._highlightDecorations = changeAccessor.deltaDecorations(this._highlightDecorations, [ { range, options: { description: 'find-match-quick-access-range-highlight', className: 'rangeHighlight', isWholeLine: true } }, { range, options: { description: 'find-match-quick-access-range-highlight-overview', overviewRuler: { color: themeColorFromId(overviewRulerRangeHighlight), position: OverviewRulerLane.Full } } } ]); }); } </ins> } export abstract class SelectionMatchFindAction extends EditorAction {


return null; } <del> const linkUrl = this.extractLinkUrl(preprocessedLink); </del> <ins> const linkUrl = removeLinkSuffix(preprocessedLink); </ins> if (!linkUrl) { this._resolvedLinkCache.set(link, null); return null;


@IEnvironmentService private readonly environmentService: IEnvironmentService, @IRequestService protected requestService: IRequestService, @ILogService protected logService: ILogService, <del> ) { </del> <ins> ) { } /** * This must be called before any other call. This is a performance * optimization, to avoid using extra CPU cycles before first window open. * https://github.com/microsoft/vscode/issues/89784 */ initialize(): void { </ins> if (!this.environmentService.isBuilt) { return; // updates are never enabled when running out of sources }


import { INotificationService } from 'vs/platform/notification/common/notification'; import { IAction, Action } from 'vs/base/common/actions'; import { normalizeDriveLetter } from 'vs/base/common/labels'; <ins> import { RunOnceScheduler } from 'vs/base/common/async'; </ins> const DEBUG_BREAKPOINTS_KEY = 'debug.breakpoint'; const DEBUG_BREAKPOINTS_ACTIVATED_KEY = 'debug.breakpointactivated';


} }); } <ins> public getLenses(): CodeLensWidget[] { return this._lenses; } } export class ShowLensesInCurrentLineCommand extends EditorCommand { public runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor, args: any): void | Promise<void> { const quickInputService = accessor.get(IQuickInputService); const commandService = accessor.get(ICommandService); const notificationService = accessor.get(INotificationService); const lineNumber = editor.getSelection()?.positionLineNumber; const codelensController = editor.getContribution(CodeLensContribution.ID) as CodeLensContribution; const activeLensesWidgets = codelensController.getLenses().filter(lens => lens.getLineNumber() === lineNumber); const commandArguments: Map<string, any[] | undefined> = new Map(); const items: (IQuickPickItem | IQuickPickSeparator)[] = []; activeLensesWidgets.forEach(widget => { widget.getItems().forEach(codelens => { const command = codelens.symbol.command; if (!command) { return; } items.push({ id: command.id, label: command.title }); commandArguments.set(command.id, command.arguments); }); }); // We dont want an empty picker if (!items.length) { return; } quickInputService.pick(items, { canPickMany: false }).then(item => { const id = item.id!; commandService.executeCommand(id, ...(commandArguments.get(id) || [])).catch(err => notificationService.error(err)); }); } </ins> } registerEditorContribution(CodeLensContribution.ID, CodeLensContribution); <ins> const showLensesInCurrentLineCommand = new ShowLensesInCurrentLineCommand({ id: 'codelens.showLensesInCurrentLine', precondition: undefined }); showLensesInCurrentLineCommand.register(); </ins>


} }, { <ins> "name": "Markup Headings", "scope": "markup.heading", "settings": { "fontStyle": "bold" } }, { </ins> "scope": "token.info-token", "settings": { "foreground": "#6796e6"


} } <ins> class ShowCodeVersion extends Action { public static readonly ID = 'workbench.action.showCodeVersion'; public static LABEL = nls.localize('version', "Show version of '{0}' installed", product.applicationName); constructor( id: string, label: string, @IMessageService private messageService: IMessageService ) { super(id, label); } run(): TPromise<void> { this.messageService.show(Severity.Info, nls.localize('successFromVersion', "'{0}' version - {1}", product.applicationName, IPackageConfiguration.version)); return TPromise.as(null); } } </ins> if (process.platform === 'darwin') { const category = nls.localize('shellCommand', "Shell Command"); const workbenchActionsRegistry = Registry.as<IWorkbenchActionRegistry>(ActionExtensions.WorkbenchActions); workbenchActionsRegistry.registerWorkbenchAction(new SyncActionDescriptor(InstallAction, InstallAction.ID, InstallAction.LABEL), 'Shell Command: Install 'code' command in PATH', category); workbenchActionsRegistry.registerWorkbenchAction(new SyncActionDescriptor(UninstallAction, UninstallAction.ID, UninstallAction.LABEL), 'Shell Command: Uninstall 'code' command from PATH', category); <ins> workbenchActionsRegistry.registerWorkbenchAction(new SyncActionDescriptor(ShowCodeVersion, ShowCodeVersion.ID, ShowCodeVersion.LABEL), 'Shell Command: Show 'code' version', category); </ins> }


// De-prioritze auto-imports // https://github.com/microsoft/vscode/issues/40311 this.sortText = 'uffff' + tsEntry.sortText; <ins> // Render "fancy" when source is a workspace path const qualifierCandidate = vscode.workspace.asRelativePath(tsEntry.source); if (qualifierCandidate !== tsEntry.source) { this.label2 = { name: tsEntry.name, qualifier: qualifierCandidate }; } </ins> } else { this.sortText = tsEntry.sortText; }


import { INotebookKernelService } from 'vs/workbench/contrib/notebook/common/notebookKernelService'; import { IEditorService } from 'vs/workbench/services/editor/common/editorService'; <del> export type contextMenuArg = { source?: string; type?: string; value?: string; expression?: string; language?: string; extensionId?: string }; </del> <ins> export type contextMenuArg = { source: string; name: string; type?: string; value?: string; expression?: string; language?: string; extensionId?: string }; </ins> export class NotebookVariablesView extends ViewPane {


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


promises.push(this.uninstallInServer(server, extensions)); } <del> await Promise.allSettled(promises); </del> <ins> const result = await Promise.allSettled(promises); const errors = result.filter(r => r.status === 'rejected').map(r => r.reason); if (errors.length) { throw new Error(errors.map(e => e.message).join('n')); } </ins> } private async uninstallInServer(server: IExtensionManagementServer, extensions: UninstallExtensionInfo[]): Promise<void> {


readonly executingCommandObject: ITerminalCommand | undefined; /** The current cwd at the cursor's position. */ readonly cwd: string | undefined; <ins> /** * Whether a command is currently being input. If the a command is current not being input or * the state cannot reliably be detected the fallback of undefined will be used. */ readonly hasInput: boolean | undefined; </ins> readonly onCommandStarted: Event<ITerminalCommand>; readonly onCommandFinished: Event<ITerminalCommand>; readonly onCommandInvalidated: Event<ITerminalCommand[]>;


import { DomEmitter } from 'vs/base/browser/event'; import { CommentContextKeys } from 'vs/workbench/contrib/comments/common/commentContextKeys'; import { FileAccess } from 'vs/base/common/network'; <ins> import { COMMENTS_SECTION, ICommentsConfiguration } from 'vs/workbench/contrib/comments/common/commentsConfiguration'; </ins> class CommentsActionRunner extends ActionRunner { protected override async runAction(action: IAction, context: any[]): Promise<void> {


import { TreeResourceNavigator, WorkbenchTree } from 'vs/platform/list/browser/listService'; import { INotificationService, Severity } from 'vs/platform/notification/common/notification'; import { IProgressService } from 'vs/platform/progress/common/progress'; <del> import { IPatternInfo, ISearchComplete, ISearchConfiguration, ISearchHistoryService, ISearchHistoryValues, ISearchProgressItem, ITextQuery, VIEW_ID, SearchErrorCode } from 'vs/platform/search/common/search'; </del> <ins> import { IPatternInfo, ISearchComplete, ISearchConfiguration, ISearchHistoryService, ISearchHistoryValues, ISearchProgressItem, ITextQuery, VIEW_ID, SearchErrorCode, ISearchConfigurationProperties } from 'vs/platform/search/common/search'; </ins> import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage'; import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; import { diffInserted, diffInsertedOutline, diffRemoved, diffRemovedOutline, editorFindMatchHighlight, editorFindMatchHighlightBorder, listActiveSelectionForeground } from 'vs/platform/theme/common/colorRegistry';


} async getRecentlyOpened(): Promise<IRecentlyOpened> { <del> const workspaces: Array<IRecentFolder | IRecentWorkspace> = []; const files: IRecentFile[] = []; </del> <ins> return this.mergeEntriesFromStorage(); } </ins> <del> await this.addEntriesFromStorage(workspaces, files); </del> <ins> private async mergeEntriesFromStorage(existingEntries?: IRecentlyOpened): Promise<IRecentlyOpened> { </ins> <del> return { workspaces, files }; } </del> <ins> // Build maps for more efficient lookup of existing entries that // are passed in by storing based on workspace/file identifier const mapWorkspaceIdToWorkspace = new ResourceMap<IRecentFolder | IRecentWorkspace>(uri => extUriBiasedIgnorePathCase.getComparisonKey(uri)); if (existingEntries?.workspaces) { for (const workspace of existingEntries.workspaces) { mapWorkspaceIdToWorkspace.set(this.location(workspace), workspace); } } </ins> <del> private async addEntriesFromStorage(workspaces: Array<IRecentFolder | IRecentWorkspace>, files: IRecentFile[]): Promise<void> { </del> <ins> const mapFileIdToFile = new ResourceMap<IRecentFile>(uri => extUriBiasedIgnorePathCase.getComparisonKey(uri)); if (existingEntries?.files) { for (const file of existingEntries.files) { mapFileIdToFile.set(this.location(file), file); } } // Merge in entries from storage, preserving existing known entries </ins> <del> // Get from storage const recents = await this.getRecentlyOpenedFromStorage(); for (const recent of recents.workspaces) { const index = isRecentFolder(recent) ? this.indexOfFolder(workspaces, recent.folderUri) : this.indexOfWorkspace(workspaces, recent.workspace); if (index >= 0) { workspaces[index].label = workspaces[index].label || recent.label; </del> <ins> const recentFromStorage = await this.getRecentlyOpenedFromStorage(); for (const recentWorkspaceFromStorage of recentFromStorage.workspaces) { const existingRecentWorkspace = mapWorkspaceIdToWorkspace.get(this.location(recentWorkspaceFromStorage)); if (existingRecentWorkspace) { existingRecentWorkspace.label = existingRecentWorkspace.label ?? recentWorkspaceFromStorage.label; </ins> } else { <del> workspaces.push(recent); </del> <ins> mapWorkspaceIdToWorkspace.set(this.location(recentWorkspaceFromStorage), recentWorkspaceFromStorage); </ins> } } <del> for (const recent of recents.files) { const index = this.indexOfFile(files, recent.fileUri); if (index >= 0) { files[index].label = files[index].label || recent.label; </del> <ins> for (const recentFileFromStorage of recentFromStorage.files) { const existingRecentFile = mapFileIdToFile.get(this.location(recentFileFromStorage)); if (existingRecentFile) { existingRecentFile.label = existingRecentFile.label ?? recentFileFromStorage.label; </ins> } else { <del> files.push(recent); </del> <ins> mapFileIdToFile.set(this.location(recentFileFromStorage), recentFileFromStorage); </ins> } } <ins> return { workspaces: [...mapWorkspaceIdToWorkspace.values()], files: [...mapFileIdToFile.values()] }; </ins> } private async getRecentlyOpenedFromStorage(): Promise<IRecentlyOpened> {


import { CancellationToken } from 'vs/base/common/cancellation'; import { IQuickPickItem, IPickOptions, IInputOptions, IQuickNavigateConfiguration, IQuickPick, IQuickInputButton, IInputBox, QuickPickInput } from 'vs/base/parts/quickinput/common/quickInput'; <del> export { IQuickPickItem, IPickOptions, IInputOptions, IQuickNavigateConfiguration, IQuickPick, IQuickInput, IQuickInputButton, IInputBox, IQuickPickItemButtonEvent, QuickPickInput, IQuickPickSeparator, IKeyMods } from 'vs/base/parts/quickinput/common/quickInput'; </del> <ins> export * from 'vs/base/parts/quickinput/common/quickInput'; </ins> export const IQuickInputService = createDecorator<IQuickInputService>('quickInputService');


import { stripIcons } from 'vs/base/common/iconLabels'; import { defaultButtonStyles, defaultCheckboxStyles, defaultDialogStyles, defaultInputBoxStyles } from 'vs/platform/theme/browser/defaultStyles'; import { ResultKind } from 'vs/platform/keybinding/common/keybindingResolver'; <ins> import { IUserActivityService } from 'vs/workbench/services/userActivity/common/userActivityService'; </ins> export class ProgressService extends Disposable implements IProgressService {


return; } this.isTreeLayoutViewVisible = visible; <ins> this.updateIndentStyles(this.themeService.getFileIconTheme()); </ins> this.refreshTree(); }


.extension-list-item > .icon-container { position: relative; <ins> display: flex; align-items: center; </ins> } .extension-list-item > .icon-container > .icon { width: 42px; height: 42px; <del> padding: 10px 14px 10px 0; </del> <ins> padding-right: 14px; </ins> flex-shrink: 0; object-fit: contain; }