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


} export const config = { <del> version: product.electronRepository ? '22.4.4' : util.getElectronVersion(), </del> <ins> version: product.electronRepository ? '22.4.5' : util.getElectronVersion(), </ins> productAppName: product.nameLong, companyName: 'Microsoft Corporation', copyright: 'Copyright (C) 2023 Microsoft. All rights reserved',


const electronOpts = _.extend({}, config, { platform: process.platform, arch: arch === 'armhf' ? 'arm' : arch, <del> ffmpegChromium: true, </del> <ins> ffmpegChromium: false, </ins> keepDefaultApp: true });


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


/** * Removes the optional link suffix which contains line and column information. <del> * @param link The link to parse. </del> <ins> * @param link The link to use. </ins> */ export function removeLinkSuffix(link: string): string { const suffix = getLinkSuffix(link)?.suffix;


} /** <ins> * Removes any query string from the link. * @param link The link to use. */ export function removeLinkQueryString(link: string): string { // Skip ? in UNC paths const start = link.startsWith('?') ? 4 : 0; const index = link.indexOf('?', start); if (index === -1) { return link; } return link.substring(0, index); } /** </ins> * Returns the optional link suffix which contains line and column information. * @param link The link to parse. */


*--------------------------------------------------------------------------------------------*/ import { ITerminalLinkResolver, ResolvedLink } from 'vs/workbench/contrib/terminalContrib/links/browser/links'; <del> import { removeLinkSuffix, winDrivePrefix } from 'vs/workbench/contrib/terminalContrib/links/browser/terminalLinkParsing'; </del> <ins> import { removeLinkSuffix, removeLinkQueryString, winDrivePrefix } from 'vs/workbench/contrib/terminalContrib/links/browser/terminalLinkParsing'; </ins> import { URI } from 'vs/base/common/uri'; import { ITerminalBackend, ITerminalProcessManager } from 'vs/workbench/contrib/terminal/common/terminal'; import { Schemas } from 'vs/base/common/network';


} } <del> // Remove any line/col suffix before processing the path </del> <ins> // Remove any line/col suffix </ins> let linkUrl = removeLinkSuffix(link); <del> if (!linkUrl) { </del> <ins> // Remove any query string linkUrl = removeLinkQueryString(linkUrl); // Exit early if the link is determines as not valid already if (linkUrl.length === 0) { </ins> cache.set(link, null); return null; }


import { deepStrictEqual, ok, strictEqual } from 'assert'; import { OperatingSystem } from 'vs/base/common/platform'; <del> import { detectLinks, detectLinkSuffixes, getLinkSuffix, IParsedLink, removeLinkSuffix } from 'vs/workbench/contrib/terminalContrib/links/browser/terminalLinkParsing'; </del> <ins> import { detectLinks, detectLinkSuffixes, getLinkSuffix, IParsedLink, removeLinkQueryString, removeLinkSuffix } from 'vs/workbench/contrib/terminalContrib/links/browser/terminalLinkParsing'; </ins> interface ITestLink { link: string;


); }); }); <ins> suite('removeLinkQueryString', () => { test('should remove any query string from the link', () => { strictEqual(removeLinkQueryString('?a=b'), ''); strictEqual(removeLinkQueryString('foo?a=b'), 'foo'); strictEqual(removeLinkQueryString('./foo?a=b'), './foo'); strictEqual(removeLinkQueryString('/foo/bar?a=b'), '/foo/bar'); strictEqual(removeLinkQueryString('foo?a=b?'), 'foo'); strictEqual(removeLinkQueryString('foo?a=b&c=d'), 'foo'); }); test('should respect ? in UNC paths', () => { strictEqual(removeLinkQueryString('?foo?a=b'), '?foo',); }); }); </ins> suite('detectLinks', () => { test('foo(1, 2) bar[3, 4] "baz" on line 5', () => { deepStrictEqual(


'builtin-extensions-dir': { type: 'string' }, 'list-extensions': { type: 'boolean', cat: 'e', description: localize('listExtensions', "List the installed extensions.") }, 'show-versions': { type: 'boolean', cat: 'e', description: localize('showVersions', "Show versions of installed extensions, when using --list-extensions.") }, <del> 'category': { type: 'string', cat: 'e', description: localize('category', "Filters installed extensions by provided category, when using --list-extensions."), args: 'category' }, </del> <ins> 'category': { type: 'string', allowEmptyValue: true, cat: 'e', description: localize('category', "Filters installed extensions by provided category, when using --list-extensions."), args: 'category' }, </ins> 'install-extension': { type: 'string[]', cat: 'e', args: 'ext-id | path', description: localize('installExtension', "Installs or updates an extension. The argument is either an extension id or a path to a VSIX. The identifier of an extension is '${publisher}.${name}'. Use '--force' argument to update to latest version. To install a specific version provide '@${version}'. For example: 'vscode.csharp@1.2.3'.") }, 'pre-release': { type: 'boolean', cat: 'e', description: localize('install prerelease', "Installs the pre-release version of the extension, when using --install-extension") }, 'uninstall-extension': { type: 'string[]', cat: 'e', args: 'ext-id', description: localize('uninstallExtension', "Uninstalls an extension.") },


pick: async () => { // Do a late 'onDebugDynamicConfigurationsName' activation so extensions are not activated too early #108578 await this.adapterManager.activateDebuggers(onDebugDynamicConfigurationsName, type); <del> const disposables = new DisposableStore(); const input = disposables.add(this.quickInputService.createQuickPick<IDynamicPickItem>()); input.busy = true; input.placeholder = nls.localize('selectConfiguration', "Select Launch Configuration"); input.show(); const chosenPromise = new Promise<IDynamicPickItem | undefined>(resolve => { disposables.add(input.onDidAccept(() => resolve(input.activeItems[0]))); disposables.add(input.onDidTriggerItemButton(async (context) => { resolve(undefined); const { launch, config } = context.item; await launch.openConfigFile({ preserveFocus: false, type: config.type, suppressInitialConfigs: true }); // Only Launch have a pin trigger button await (launch as Launch).writeConfiguration(config); await this.selectConfiguration(launch, config.name); this.removeRecentDynamicConfigurations(config.name, config.type); })); }); </del> const token = new CancellationTokenSource(); const picks: Promise<IDynamicPickItem[]>[] = [];


} }); <ins> const disposables = new DisposableStore(); const input = disposables.add(this.quickInputService.createQuickPick<IDynamicPickItem>()); input.busy = true; input.placeholder = nls.localize('selectConfiguration', "Select Launch Configuration"); const chosenPromise = new Promise<IDynamicPickItem | undefined>(resolve => { disposables.add(input.onDidAccept(() => resolve(input.activeItems[0]))); disposables.add(input.onDidTriggerItemButton(async (context) => { resolve(undefined); const { launch, config } = context.item; await launch.openConfigFile({ preserveFocus: false, type: config.type, suppressInitialConfigs: true }); // Only Launch have a pin trigger button await (launch as Launch).writeConfiguration(config); await this.selectConfiguration(launch, config.name); this.removeRecentDynamicConfigurations(config.name, config.type); })); }); </ins> const nestedPicks = await Promise.all(picks); const items = flatten(nestedPicks); input.items = items; input.busy = false; <ins> input.show(); </ins> const chosen = await chosenPromise; disposables.dispose();


} else { if (options.hideOnHover === undefined) { // When unset, will default to true when it's a string or when it's markdown that  // appears to have a link using a naive check for '](' hideOnHover = typeof options.content === 'string' || isMarkdownString(options.content) && !options.content.value.includes('](');   // appears to have a link using a naive check for '](' and '' hideOnHover = typeof options.content === 'string' || isMarkdownString(options.content) && !options.content.value.includes('](') && !options.content.value.includes('');  } else { // It's set explicitly hideOnHover = options.hideOnHover;


const isWrapped = buffer.getLine(i + 1)?.isWrapped; currentLine += line.translateToString(!isWrapped); if (currentLine && !isWrapped || i === (buffer.baseY + this._xterm.raw.rows - 1)) { <del> const line = replaceWithNonBreakingSpaces(currentLine); </del> if (line.length) { <del> cachedLines.push(line); </del> <ins> cachedLines.push(currentLine); </ins> currentLine = ''; } }


const isWrapped = buffer.getLine(i + 1)?.isWrapped; currentLine += line.translateToString(!isWrapped); if (currentLine && !isWrapped || i === (buffer.baseY + this._xterm.raw.rows - 1)) { <del> const line = replaceWithNonBreakingSpaces(currentLine); if (line.length) { </del> <ins> if (currentLine.length) { </ins> this._priorEditorViewportLineCount++; <del> this._lines.push(line); </del> <ins> this._lines.push(currentLine); </ins> currentLine = ''; } }


this._logService.debug('Viewport content update complete, ', this._lines.length, ' lines in the viewport'); } } <del> export function replaceWithNonBreakingSpaces(s: string): string { return s.replace(new RegExp('  ', 'g'), ' xA0'); } </del>


import { writeP } from 'vs/workbench/contrib/terminal/browser/terminalTestHelpers'; import { XtermTerminal } from 'vs/workbench/contrib/terminal/browser/xterm/xtermTerminal'; import { ITerminalConfiguration } from 'vs/workbench/contrib/terminal/common/terminal'; <del> import { BufferContentTracker, replaceWithNonBreakingSpaces } from 'vs/workbench/contrib/terminalContrib/accessibility/browser/bufferContentTracker'; </del> <ins> import { BufferContentTracker } from 'vs/workbench/contrib/terminalContrib/accessibility/browser/bufferContentTracker'; </ins> import { ILifecycleService } from 'vs/workbench/services/lifecycle/common/lifecycle'; import { TestLifecycleService } from 'vs/workbench/test/browser/workbenchTestServices'; import { Terminal } from 'xterm';


assert.strictEqual(bufferTracker.lines.length, 0); await writeP(xterm.raw, prompt); xterm.clearBuffer(); <del> await bufferTracker.update(); </del> <ins> bufferTracker.update(); </ins> assert.deepStrictEqual(bufferTracker.lines, [prompt]); <del> assert.strictEqual(bufferTracker.lines.length, 1); </del> }); test('repeated updates should not change the content', async () => { assert.strictEqual(bufferTracker.lines.length, 0); await writeP(xterm.raw, prompt); <del> await bufferTracker.update(); </del> <ins> bufferTracker.update(); </ins> assert.deepStrictEqual(bufferTracker.lines, [prompt]); <del> assert.strictEqual(bufferTracker.lines.length, 1); await bufferTracker.update(); </del> <ins> bufferTracker.update(); </ins> assert.deepStrictEqual(bufferTracker.lines, [prompt]); <del> assert.strictEqual(bufferTracker.lines.length, 1); await bufferTracker.update(); </del> <ins> bufferTracker.update(); </ins> assert.deepStrictEqual(bufferTracker.lines, [prompt]); <del> assert.strictEqual(bufferTracker.lines.length, 1); </del> }); test('should add lines in the viewport and scrollback', async () => { await writeAndAssertBufferState(promptPlusData, 38, xterm.raw, bufferTracker);


test('should refresh viewport', async () => { await writeAndAssertBufferState(promptPlusData, 6, xterm.raw, bufferTracker); await writeP(xterm.raw, 'x1b[3Ainserteddata'); <del> await bufferTracker.update(); assert.deepStrictEqual(bufferTracker.lines, [promptPlusData, promptPlusData, `${promptPlusData}inserteddata`, promptPlusData, promptPlusData, promptPlusData].map(s => replaceWithNonBreakingSpaces(s))); </del> <ins> bufferTracker.update(); assert.deepStrictEqual(bufferTracker.lines, [promptPlusData, promptPlusData, `${promptPlusData}inserteddata`, promptPlusData, promptPlusData, promptPlusData]); </ins> }); test('should refresh viewport with full scrollback', async () => { <del> const content = replaceWithNonBreakingSpaces(`${prompt}rn`.repeat(1030).trimEnd()); </del> <ins> const content = `${prompt}rn`.repeat(1030).trimEnd(); </ins> await writeP(xterm.raw, content); <del> await bufferTracker.update(); </del> <ins> bufferTracker.update(); </ins> await writeP(xterm.raw, 'x1b[4Ainsertion'); <del> await bufferTracker.update(); </del> <ins> bufferTracker.update(); </ins> const expected = content.split('rn'); expected[1025] = `${prompt}insertion`; assert.deepStrictEqual(bufferTracker.lines[1025], `${prompt}insertion`);


test('should cap the size of the cached lines, removing old lines in favor of new lines', async () => { const content = `${prompt}rn`.repeat(1036).trimEnd(); await writeP(xterm.raw, content); <del> await bufferTracker.update(); const expected = content.split('rn').map(s => replaceWithNonBreakingSpaces(s)); </del> <ins> bufferTracker.update(); const expected = content.split('rn'); </ins> // delete the 6 lines that should be trimmed for (let i = 0; i < 6; i++) { expected.pop(); } // insert a new character await writeP(xterm.raw, 'x1b[2Ainsertion'); <del> await bufferTracker.update(); </del> <ins> bufferTracker.update(); </ins> expected[1027] = `${prompt}insertion`; assert.strictEqual(bufferTracker.lines.length, expected.length); assert.deepStrictEqual(bufferTracker.lines, expected);


async function writeAndAssertBufferState(data: string, rows: number, terminal: Terminal, bufferTracker: BufferContentTracker): Promise<void> { const content = `${data}rn`.repeat(rows).trimEnd(); await writeP(terminal, content); <del> await bufferTracker.update(); </del> <ins> bufferTracker.update(); </ins> assert.strictEqual(bufferTracker.lines.length, rows); <del> assert.deepStrictEqual(bufferTracker.lines, content.split('rn').map(s => replaceWithNonBreakingSpaces(s))); </del> <ins> assert.deepStrictEqual(bufferTracker.lines, content.split('rn')); </ins> }


} try { itemOrItems = Array.isArray(itemOrItems) ? itemOrItems : [itemOrItems]; <del> await Promise.all(itemOrItems.map(element => { return tree.expand(element, false); })); </del> <ins> for (const element of itemOrItems) { await tree.expand(element, false); } </ins> } catch (e) { // The extension could have changed the tree during the reveal. // Because of that, we ignore errors.


export function setup(ensureStableCode: () => string | undefined, logger: Logger) { describe('Data Loss (insiders -> insiders)', function () { <ins> // Double the timeout since these tests involve 2 startups this.timeout(4 * 60 * 1000); </ins> let app: Application | undefined = undefined; // Shared before/after handling


}); describe('Data Loss (stable -> insiders)', function () { <ins> // Double the timeout since these tests involve 2 startups this.timeout(4 * 60 * 1000); </ins> let insidersApp: Application | undefined = undefined; let stableApp: Application | undefined = undefined;


interface InputTemplate { readonly inputWidget: SCMInputWidget; <ins> inputWidgetHeight: number; </ins> readonly elementDisposables: DisposableStore; readonly templateDisposable: IDisposable; }


const inputWidget = this.instantiationService.createInstance(SCMInputWidget, inputElement, this.overflowWidgetsDomNode); templateDisposable.add(inputWidget); <del> return { inputWidget, elementDisposables: new DisposableStore(), templateDisposable }; </del> <ins> return { inputWidget, inputWidgetHeight: InputRenderer.DEFAULT_HEIGHT, elementDisposables: new DisposableStore(), templateDisposable }; </ins> } renderElement(node: ITreeNode<ISCMInput, FuzzyScore>, index: number, templateData: InputTemplate): void {


// Remember widget this.inputWidgets.set(input, templateData.inputWidget); templateData.elementDisposables.add({ <del> dispose: () => { this.inputWidgets.delete(input); this.contentHeights.delete(input); } </del> <ins> dispose: () => this.inputWidgets.delete(input) </ins> }); // Widget cursor selections


// Rerender the element whenever the editor content height changes const onDidChangeContentHeight = () => { const contentHeight = templateData.inputWidget.getContentHeight(); <del> const lastContentHeight = this.contentHeights.get(input)!; </del> this.contentHeights.set(input, contentHeight); <del> if (lastContentHeight !== contentHeight) { </del> <ins> if (templateData.inputWidgetHeight !== contentHeight) { </ins> this.updateHeight(input, contentHeight + 10); <ins> templateData.inputWidgetHeight = contentHeight; </ins> templateData.inputWidget.layout(); } };


override async setInput(newInput: GettingStartedInput, options: IEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken) { this.container.classList.remove('animatable'); this.editorInput = newInput; <del> await this.lifecycleService.when(LifecyclePhase.Restored); </del> await super.setInput(newInput, options, context, token); <ins> await this.lifecycleService.when(LifecyclePhase.Restored); </ins> await this.buildCategoriesSlide(); if (this.shouldAnimate()) { setTimeout(() => this.container.classList.add('animatable'), 0);


} result[id] = <DecorationData>[data.propagate, data.tooltip, data.badge, data.color]; } catch (e) { <del> this._logService.warn(`INVALID decoration from extension '${extensionId}': ${e}`); </del> <ins> this._logService.warn(`INVALID decoration from extension '${extensionId.identifier.value}': ${e}`); </ins> } } catch (err) { this._logService.error(err);


end set -e VSCODE_PATH_PREFIX <del> # Apply EnvironmentVariableCollections if needed if test -n "$VSCODE_ENV_REPLACE" set ITEMS (string split : $VSCODE_ENV_REPLACE) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" (echo -e "$split[2]") </del> <ins> set -g __vsc_applied_env_vars 0 function __vsc_apply_env_vars if test $__vsc_applied_env_vars -eq 1; return </ins> end <del> set -e VSCODE_ENV_REPLACE end if test -n "$VSCODE_ENV_PREPEND" set ITEMS (string split : $VSCODE_ENV_PREPEND) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" (echo -e "$split[2]")"$$split[1]" # avoid -p as it adds a space </del> <ins> set -l __vsc_applied_env_vars 1 # Apply EnvironmentVariableCollections if needed if test -n "$VSCODE_ENV_REPLACE" set ITEMS (string split : $VSCODE_ENV_REPLACE) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" (echo -e "$split[2]") end set -e VSCODE_ENV_REPLACE </ins> end <del> set -e VSCODE_ENV_PREPEND end if test -n "$VSCODE_ENV_APPEND" set ITEMS (string split : $VSCODE_ENV_APPEND) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" "$$split[1]"(echo -e "$split[2]") # avoid -a as it adds a space </del> <ins> if test -n "$VSCODE_ENV_PREPEND" set ITEMS (string split : $VSCODE_ENV_PREPEND) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" (echo -e "$split[2]")"$$split[1]" # avoid -p as it adds a space end set -e VSCODE_ENV_PREPEND end if test -n "$VSCODE_ENV_APPEND" set ITEMS (string split : $VSCODE_ENV_APPEND) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" "$$split[1]"(echo -e "$split[2]") # avoid -a as it adds a space end set -e VSCODE_ENV_APPEND </ins> end <del> set -e VSCODE_ENV_APPEND </del> end # Handle the shell integration nonce


# Sent at the start of the prompt. # Marks the beginning of the prompt (and, implicitly, a new line). function __vsc_fish_prompt_start <ins> # Applying environment variables is deferred to after config.fish has been # evaluated __vsc_apply_env_vars </ins> __vsc_esc A end


group: 'navigation/execute', when: ContextKeyExpr.and( executeNotebookCondition, <del> ContextKeyExpr.or(NOTEBOOK_INTERRUPTIBLE_KERNEL.toNegated(), NOTEBOOK_HAS_SOMETHING_RUNNING.toNegated()), </del> <ins> ContextKeyExpr.or( NOTEBOOK_INTERRUPTIBLE_KERNEL.toNegated(), NOTEBOOK_HAS_SOMETHING_RUNNING.toNegated(), ), ContextKeyExpr.and(NOTEBOOK_HAS_SOMETHING_RUNNING, NOTEBOOK_INTERRUPTIBLE_KERNEL.toNegated())?.negate(), </ins> ContextKeyExpr.equals('config.notebook.globalToolbar', true) ) }


return await this.run(Operation.Ignore, async () => { const ignoreFile = `${this.repository.root}${path.sep}.gitignore`; const textToAppend = files <del> .map(uri => relativePath(this.repository.root, uri.fsPath).replace(//g, '/')) </del> <ins> .map(uri => relativePath(this.repository.root, uri.fsPath) .replace(/|[/g, match => match === '' ? '/' : `${match}`)) </ins> .join('n'); const document = await new Promise(c => fs.exists(ignoreFile, c))


tsx: false, decorators: true }, <del> target: 'es2020', </del> <ins> target: 'es2022', </ins> loose: false, minify: { compress: false,


"./vs/*" ] }, <ins> "target": "es2022", "useDefineForClassFields": false, </ins> "lib": [ <del> "ES2016", "ES2017.Object", "ES2017.String", "ES2017.Intl", "ES2017.TypedArrays", "ES2018.AsyncIterable", "ES2018.AsyncGenerator", "ES2018.Promise", "ES2018.Regexp", "ES2018.Intl", "ES2019.Array", "ES2019.Object", "ES2019.String", "ES2019.Symbol", "ES2020.BigInt", "ES2020.Promise", "ES2020.String", "ES2020.Symbol.WellKnown", "ES2020.Intl", "ES2021.Promise", "ES2021.String", "ES2021.WeakRef", </del> <ins> "ES2022", </ins> "DOM", "DOM.Iterable", "WebWorker.ImportScripts"


"allowJs": true, "resolveJsonModule": true, "outDir": "../out/vs", <del> "target": "es2021", </del> "types": [ "keytar", "mocha",


export class ExtractError extends Error { readonly type?: ExtractErrorType; <del> readonly cause: Error; </del> constructor(type: ExtractErrorType | undefined, cause: Error) { let message = cause.message;


export abstract class ErrorHandler { <del> static { </del> <ins> static async installEarlyHandler(accessor: ServicesAccessor): Promise<void> { </ins> // increase number of stack frames (from 10, https://github.com/v8/v8/wiki/Stack-Trace-API) Error.stackTraceLimit = 100; <del> } static async installEarlyHandler(accessor: ServicesAccessor): Promise<void> { </del> // does NOT dependent of extension information, can be installed immediately, and simply forwards // to the log service and main thread errors const logService = accessor.get(ILogService);


private async initialize(): Promise<void> { await this.extensionsScannerService.initializeDefaultProfileExtensions(); <del> await this.onDidChangeProfiles(this.userDataProfilesService.profiles, []); </del> <ins> await this.onDidChangeProfiles(this.userDataProfilesService.profiles); </ins> this.registerListeners(); await this.uninstallExtensionsNotInProfiles(); } private registerListeners(): void { <del> this._register(this.userDataProfilesService.onDidChangeProfiles(e => this.onDidChangeProfiles(e.added, e.removed))); </del> <ins> this._register(this.userDataProfilesService.onDidChangeProfiles(e => this.onDidChangeProfiles(e.added))); </ins> this._register(this.extensionsProfileScannerService.onAddExtensions(e => this.onAddExtensions(e))); this._register(this.extensionsProfileScannerService.onDidAddExtensions(e => this.onDidAddExtensions(e))); this._register(this.extensionsProfileScannerService.onRemoveExtensions(e => this.onRemoveExtensions(e)));


this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e))); } <del> private async onDidChangeProfiles(added: readonly IUserDataProfile[], removed: readonly IUserDataProfile[]): Promise<void> { </del> <ins> private async onDidChangeProfiles(added: readonly IUserDataProfile[]): Promise<void> { </ins> try { <del> await Promise.all(removed.map(profile => { this.extensionsProfileWatchDisposables.deleteAndDispose(profile.id); return this.removeExtensionsFromProfile(profile.extensionsResource); })); </del> if (added.length) { await Promise.all(added.map(profile => { this.extensionsProfileWatchDisposables.set(profile.id, combinedDisposable(


} } <del> private async removeExtensionsFromProfile(removedProfile: URI): Promise<void> { for (const key of [...this.allExtensions.keys()]) { this.removeExtensionWithKey(key, removedProfile); } await this.uninstallExtensionsNotInProfiles(); } </del> private async uninstallExtensionsNotInProfiles(toUninstall?: IExtension[]): Promise<void> { if (!toUninstall) { const installed = await this.extensionManagementService.scanAllUserInstalledExtensions();


this.logService.error(error); } } <del> try { if (this.profiles.length === 1) { await this.fileService.del(this.profilesHome, { recursive: true }); } else { await this.fileService.del(profile.location, { recursive: true }); } } catch (error) { this.logService.error(error); } </del> } async setProfileForWorkspace(workspaceIdentifier: IAnyWorkspaceIdentifier, profileToSet: IUserDataProfile): Promise<void> {


// If HEAD is not published, make sure it is && !repository?.state.HEAD?.upstream ) { <del> const publishBranch = vscode.l10n.t('Publish Branch'); </del> <ins> const publishBranch = vscode.l10n.t('Publish Branch & Copy Link'); </ins> const selection = await vscode.window.showInformationMessage( vscode.l10n.t('The current branch is not published to the remote. Would you like to publish your branch before copying a link?'), { modal: true },


} const uncommittedChanges = [...repository.state.workingTreeChanges, ...repository.state.indexChanges]; <del> if (uncommittedChanges.find((c) => c.uri.toString() === file.toString())) { </del> <ins> if (uncommittedChanges.find((c) => c.uri.toString() === file.toString()) && !repository.state.HEAD?.ahead && !repository.state.HEAD?.behind) { </ins> const commitChanges = vscode.l10n.t('Commit Changes'); const copyAnyway = vscode.l10n.t('Copy Anyway'); const selection = await vscode.window.showWarningMessage(


throw new vscode.CancellationError(); } } else if (repository.state.HEAD?.ahead) { <del> const pushCommits = vscode.l10n.t('Push Commits'); </del> <ins> const pushCommits = vscode.l10n.t('Push Commits & Copy Link'); </ins> const selection = await vscode.window.showInformationMessage( vscode.l10n.t('The current branch has unpublished commits. Would you like to push your commits before copying a link?'), { modal: true },


} await repository.push(); <ins> } else if (repository.state.HEAD?.behind) { const pull = vscode.l10n.t('Pull Changes & Copy Link'); const selection = await vscode.window.showInformationMessage( vscode.l10n.t('The current branch is not up to date. Would you like to pull before copying a link?'), { modal: true }, pull ); if (selection !== pull) { throw new vscode.CancellationError(); } await repository.pull(); </ins> } await repository.status();


if (sessionData) { this._persistedSessions = this.deserializeChats(sessionData); const countsForLog = Object.keys(this._persistedSessions).length; <del> this.trace('constructor', `Restored ${countsForLog} persisted sessions`); </del> <ins> if (countsForLog > 0) { this.trace('constructor', `Restored ${countsForLog} persisted sessions`); } </ins> } else { this._persistedSessions = {}; <del> this.trace('constructor', 'No persisted sessions'); </del> } this._transferred = this.getTransferredSession();


.filter(session => session.requests.length)); allSessions.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0)); allSessions = allSessions.slice(0, maxPersistedSessions); <del> this.trace('onWillSaveState', `Persisting ${allSessions.length} sessions`); </del> <ins> if (allSessions.length) { this.trace('onWillSaveState', `Persisting ${allSessions.length} sessions`); } </ins> const serialized = JSON.stringify(allSessions); <del> this.trace('onWillSaveState', `Persisting ${serialized.length} chars`); </del> <ins> if (allSessions.length) { this.trace('onWillSaveState', `Persisting ${serialized.length} chars`); } </ins> this.storageService.store(serializedChatKey, serialized, StorageScope.WORKSPACE, StorageTarget.MACHINE); }


await this.configurationEditing.writeConfiguration(editableConfigurationTarget, { key, value }, { scopes: overrides, ...options }); switch (editableConfigurationTarget) { case EditableConfigurationTarget.USER_LOCAL: <del> if (this.applicationConfiguration && this.configurationRegistry.getConfigurationProperties()[key].scope === ConfigurationScope.APPLICATION) { </del> <ins> if (this.applicationConfiguration && this.configurationRegistry.getConfigurationProperties()[key]?.scope === ConfigurationScope.APPLICATION) { </ins> await this.reloadApplicationConfiguration(); } else { await this.reloadLocalUserConfiguration();


override hide() { super.hide(); this._findWidgetVisible.reset(); <del> this._instance.focus(); </del> <ins> this._instance.focus(true); </ins> this._instance.xterm?.clearSearchDecorations(); }


this._logService.debug(`TextAreaSyncAddon#updateCommandAndCursor: no line`); return; } <del> if (!!currentCommand.commandStartX) { </del> <ins> if (currentCommand.commandStartX !== undefined) { </ins> this._currentCommand = commandLine.substring(currentCommand.commandStartX); this._cursorX = buffer.cursorX - currentCommand.commandStartX; } else {


return this._proxy.setTerminalLayoutInfo(args); } async getTerminalLayoutInfo(args: IGetTerminalLayoutInfoArgs): Promise<ITerminalsLayoutInfo | undefined> { <del> return await this._proxy.getTerminalLayoutInfo(args); </del> <ins> // This is optional as we want reconnect requests to go through only if the pty host exists. // Revive is handled specially as reviveTerminalProcesses is guaranteed to be called before // the request for layout info. return this._optionalProxy?.getTerminalLayoutInfo(args); </ins> } async requestDetachInstance(workspaceId: string, instanceId: number): Promise<IProcessDetails | undefined> {


}; } catch (e) { this._logService.warn(`Couldn't get layout info, a terminal was probably disconnected`, e.message); <del> this._logService.info('Reattach to wrong terminal debug info - layout info by id', t); this._logService.info('Reattach to wrong terminal debug info - _revivePtyIdMap', Array.from(this._revivedPtyIdMap.values())); </del> <ins> this._logService.debug('Reattach to wrong terminal debug info - layout info by id', t); this._logService.debug('Reattach to wrong terminal debug info - _revivePtyIdMap', Array.from(this._revivedPtyIdMap.values())); this._logService.debug('Reattach to wrong terminal debug info - _ptys ids', Array.from(this._ptys.keys())); </ins> // this will be filtered out and not reconnected return { terminal: null,


// Revive processes if needed const serializedState = this._storageService.get(TerminalStorageKeys.TerminalBufferState, StorageScope.WORKSPACE); <del> const parsed = this._deserializeTerminalState(serializedState); if (!parsed) { return undefined; } try { // Note that remote terminals do not get their environment re-resolved unlike in local terminals mark('code/terminal/willReviveTerminalProcessesRemote'); await this._remoteTerminalChannel.reviveTerminalProcesses(parsed, Intl.DateTimeFormat().resolvedOptions().locale); mark('code/terminal/didReviveTerminalProcessesRemote'); this._storageService.remove(TerminalStorageKeys.TerminalBufferState, StorageScope.WORKSPACE); // If reviving processes, send the terminal layout info back to the pty host as it // will not have been persisted on application exit const layoutInfo = this._storageService.get(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); if (layoutInfo) { mark('code/terminal/willSetTerminalLayoutInfoRemote'); await this._remoteTerminalChannel.setTerminalLayoutInfo(JSON.parse(layoutInfo)); mark('code/terminal/didSetTerminalLayoutInfoRemote'); this._storageService.remove(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); </del> <ins> const reviveBufferState = this._deserializeTerminalState(serializedState); if (reviveBufferState && reviveBufferState.length > 0) { try { // Note that remote terminals do not get their environment re-resolved unlike in local terminals mark('code/terminal/willReviveTerminalProcessesRemote'); await this._remoteTerminalChannel.reviveTerminalProcesses(reviveBufferState, Intl.DateTimeFormat().resolvedOptions().locale); mark('code/terminal/didReviveTerminalProcessesRemote'); this._storageService.remove(TerminalStorageKeys.TerminalBufferState, StorageScope.WORKSPACE); // If reviving processes, send the terminal layout info back to the pty host as it // will not have been persisted on application exit const layoutInfo = this._storageService.get(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); if (layoutInfo) { mark('code/terminal/willSetTerminalLayoutInfoRemote'); await this._remoteTerminalChannel.setTerminalLayoutInfo(JSON.parse(layoutInfo)); mark('code/terminal/didSetTerminalLayoutInfoRemote'); this._storageService.remove(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); } } catch (e: unknown) { this._logService.warn('RemoteTerminalBackend#getTerminalLayoutInfo Error', e && typeof e === 'object' && 'message' in e ? e.message : e); </ins> } <del> } catch (e: unknown) { this._logService.warn('RemoteTerminalBackend#getTerminalLayoutInfo Error', e && typeof e === 'object' && 'message' in e ? e.message : e); </del> } return this._remoteTerminalChannel.getTerminalLayoutInfo();


// Revive processes if needed const serializedState = this._storageService.get(TerminalStorageKeys.TerminalBufferState, StorageScope.WORKSPACE); <del> const parsed = this._deserializeTerminalState(serializedState); if (!parsed) { return undefined; } try { // Create variable resolver const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot(); const lastActiveWorkspace = activeWorkspaceRootUri ? withNullAsUndefined(this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri)) : undefined; const variableResolver = terminalEnvironment.createVariableResolver(lastActiveWorkspace, await this._terminalProfileResolverService.getEnvironment(this.remoteAuthority), this._configurationResolverService); // Re-resolve the environments and replace it on the state so local terminals use a fresh // environment mark('code/terminal/willGetReviveEnvironments'); await Promise.all(parsed.map(state => new Promise<void>(r => { this._resolveEnvironmentForRevive(variableResolver, state.shellLaunchConfig).then(freshEnv => { state.processLaunchConfig.env = freshEnv; r(); }); }))); mark('code/terminal/didGetReviveEnvironments'); mark('code/terminal/willReviveTerminalProcesses'); await this._proxy.reviveTerminalProcesses(workspaceId, parsed, Intl.DateTimeFormat().resolvedOptions().locale); mark('code/terminal/didReviveTerminalProcesses'); this._storageService.remove(TerminalStorageKeys.TerminalBufferState, StorageScope.WORKSPACE); // If reviving processes, send the terminal layout info back to the pty host as it // will not have been persisted on application exit const layoutInfo = this._storageService.get(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); if (layoutInfo) { mark('code/terminal/willSetTerminalLayoutInfo'); await this._proxy.setTerminalLayoutInfo(JSON.parse(layoutInfo)); mark('code/terminal/didSetTerminalLayoutInfo'); this._storageService.remove(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); </del> <ins> const reviveBufferState = this._deserializeTerminalState(serializedState); if (reviveBufferState && reviveBufferState.length > 0) { try { // Create variable resolver const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot(); const lastActiveWorkspace = activeWorkspaceRootUri ? withNullAsUndefined(this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri)) : undefined; const variableResolver = terminalEnvironment.createVariableResolver(lastActiveWorkspace, await this._terminalProfileResolverService.getEnvironment(this.remoteAuthority), this._configurationResolverService); // Re-resolve the environments and replace it on the state so local terminals use a fresh // environment mark('code/terminal/willGetReviveEnvironments'); await Promise.all(reviveBufferState.map(state => new Promise<void>(r => { this._resolveEnvironmentForRevive(variableResolver, state.shellLaunchConfig).then(freshEnv => { state.processLaunchConfig.env = freshEnv; r(); }); }))); mark('code/terminal/didGetReviveEnvironments'); mark('code/terminal/willReviveTerminalProcesses'); await this._proxy.reviveTerminalProcesses(workspaceId, reviveBufferState, Intl.DateTimeFormat().resolvedOptions().locale); mark('code/terminal/didReviveTerminalProcesses'); this._storageService.remove(TerminalStorageKeys.TerminalBufferState, StorageScope.WORKSPACE); // If reviving processes, send the terminal layout info back to the pty host as it // will not have been persisted on application exit const layoutInfo = this._storageService.get(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); if (layoutInfo) { mark('code/terminal/willSetTerminalLayoutInfo'); await this._proxy.setTerminalLayoutInfo(JSON.parse(layoutInfo)); mark('code/terminal/didSetTerminalLayoutInfo'); this._storageService.remove(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); } } catch (e: unknown) { this._logService.warn('LocalTerminalBackend#getTerminalLayoutInfo Error', e && typeof e === 'object' && 'message' in e ? e.message : e); </ins> } <del> } catch (e: unknown) { this._logService.warn('LocalTerminalBackend#getTerminalLayoutInfo Error', e && typeof e === 'object' && 'message' in e ? e.message : e); </del> } return this._proxy.getTerminalLayoutInfo(layoutArgs);


private viewHasSomeCollapsibleRootItem: IContextKey<boolean>; private viewVisibleContextKey: IContextKey<boolean>; <ins> private setTreeInputPromise: Promise<void> | undefined; </ins> private horizontalScrolling: boolean | undefined; private dragHandler!: DelayedDragHandler;


// save view state this._register(this.storageService.onWillSaveState(() => { <del> this.storageService.store(ExplorerView.TREE_VIEW_STATE_STORAGE_KEY, JSON.stringify(this.tree.getViewState()), StorageScope.WORKSPACE, StorageTarget.MACHINE); </del> <ins> this.storeTreeViewState(); </ins> })); }


} } <ins> private storeTreeViewState() { this.storageService.store(ExplorerView.TREE_VIEW_STATE_STORAGE_KEY, JSON.stringify(this.tree.getViewState()), StorageScope.WORKSPACE, StorageTarget.MACHINE); } </ins> private setContextKeys(stat: ExplorerItem | null | undefined): void { const folders = this.contextService.getWorkspace().folders; const resource = stat ? stat.resource : folders[folders.length - 1].uri;


return Promise.resolve(undefined); } <ins> // Wait for the last execution to complete before executing if (this.setTreeInputPromise) { await this.setTreeInputPromise; } </ins> const initialInputSetup = !this.tree.getInput(); if (initialInputSetup) { perf.mark('code/willResolveExplorer');


} const previousInput = this.tree.getInput(); <del> const promise = this.tree.setInput(input, viewState).then(async () => { </del> <ins> const promise = this.setTreeInputPromise = this.tree.setInput(input, viewState).then(async () => { </ins> if (Array.isArray(input)) { if (!viewState || previousInput instanceof ExplorerItem) { // There is no view state for this workspace (we transitioned from a folder workspace?), expand up to five roots.


const treeInputArray = Array.isArray(treeInput) ? treeInput : Array.from(treeInput.children.values()); // Has collapsible root when anything is expanded this.viewHasSomeCollapsibleRootItem.set(hasExpandedNode(this.tree, treeInputArray)); <ins> // synchronize state to cache this.storeTreeViewState(); </ins> } override dispose(): void {


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


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


window.localStorage.removeItem(WebLocaleService._LOCAL_STORAGE_LOCALE_KEY); window.localStorage.removeItem(WebLocaleService._LOCAL_STORAGE_EXTENSION_ID_KEY); <del> if (Language.value() === navigator.language) { </del> <ins> if (Language.value() === navigator.language.toLowerCase()) { </ins> return; }


[[package]] name = "inno_updater" <del> version = "0.10.0" </del> <ins> version = "0.10.1" </ins> dependencies = [ "byteorder", "crc",


[package] name = "inno_updater" <del> version = "0.10.0" </del> <ins> version = "0.10.1" </ins> authors = ["Microsoft <monacotools@microsoft.com>"] build = "build.rs"


const rerender = () => { this.gettingStartedCategories = this.gettingStartedService.getWalkthroughs(); this.featuredExtensions = this.featuredExtensionService.getExtensions(); <del> this.buildSlideThrottle.queue(async () => await this.buildCategoriesSlide()); </del> <ins> if (this.currentWalkthrough) { const existingSteps = this.currentWalkthrough.steps.map(step => step.id); const newCategory = this.gettingStartedCategories.find(category => this.currentWalkthrough?.id === category.id); if (newCategory) { const newSteps = newCategory.steps.map(step => step.id); if (!equals(newSteps, existingSteps)) { this.buildSlideThrottle.queue(() => this.buildCategoriesSlide()); } } } else { this.buildSlideThrottle.queue(() => this.buildCategoriesSlide()); } </ins> }; this._register(this.extensionManagementService.onDidInstallExtensions(async (result) => {


isEncryptionAvailable(): Promise<boolean>; } <ins> // The values provided to the `password-store` command line switch. // Notice that they are not the same as the values returned by // `getSelectedStorageBackend` in the `safeStorage` API. export const enum PasswordStoreCLIOption { kwallet = 'kwallet', kwallet5 = 'kwallet5', gnome = 'gnome', gnomeKeyring = 'gnome-keyring', gnomeLibsecret = 'gnome-libsecret', basic = 'basic' } // The values returned by `getSelectedStorageBackend` in the `safeStorage` API. </ins> export const enum KnownStorageProvider { unknown = 'unknown', basicText = 'basic_text',


kwallet5 = 'kwallet5', kwallet6 = 'kwallet6', <ins> // The rest of these are not returned by `getSelectedStorageBackend` // but these were added for platform completeness. </ins> // Windows dplib = 'dpapi',


import { safeStorage as safeStorageElectron, app } from 'electron'; import { isMacintosh, isWindows } from 'vs/base/common/platform'; <del> import { KnownStorageProvider, IEncryptionMainService } from 'vs/platform/encryption/common/encryptionService'; </del> <ins> import { KnownStorageProvider, IEncryptionMainService, PasswordStoreCLIOption } from 'vs/platform/encryption/common/encryptionService'; </ins> import { ILogService } from 'vs/platform/log/common/log'; // These APIs are currently only supported in our custom build of electron so


@ILogService private readonly logService: ILogService ) { // if this commandLine switch is set, the user has opted in to using basic text encryption <del> if (app.commandLine.getSwitchValue('password-store') === 'basic_text') { </del> <ins> if (app.commandLine.getSwitchValue('password-store') === PasswordStoreCLIOption.basic) { </ins> safeStorage.setUsePlainTextEncryption?.(true); } }


'install-source'?: string; 'disable-updates'?: boolean; 'disable-keytar'?: boolean; <ins> 'password-store'?: string; </ins> 'disable-workspace-trust'?: boolean; 'disable-crash-reporter'?: boolean; 'crash-reporter-directory'?: string;


'disable-telemetry': { type: 'boolean' }, 'disable-updates': { type: 'boolean' }, 'disable-keytar': { type: 'boolean' }, <ins> 'password-store': { type: 'string' }, </ins> 'disable-workspace-trust': { type: 'boolean' }, 'disable-crash-reporter': { type: 'boolean' }, 'crash-reporter-directory': { type: 'string' },


import Severity from 'vs/base/common/severity'; import { localize } from 'vs/nls'; import { IDialogService } from 'vs/platform/dialogs/common/dialogs'; <del> import { IEncryptionService, KnownStorageProvider, isGnome, isKwallet } from 'vs/platform/encryption/common/encryptionService'; </del> <ins> import { IEncryptionService, KnownStorageProvider, PasswordStoreCLIOption, isGnome, isKwallet } from 'vs/platform/encryption/common/encryptionService'; </ins> import { IEnvironmentService } from 'vs/platform/environment/common/environment'; import { InstantiationType, registerSingleton } from 'vs/platform/instantiation/common/extensions'; import { ILogService } from 'vs/platform/log/common/log';


label: localize('usePlainText', "Use weaker encryption"), run: async () => { await this._encryptionService.setUsePlainTextEncryption(); <del> await this._jsonEditingService.write(this._environmentService.argvResource, [{ path: ['password-store'], value: 'basic_text' }], true); </del> <ins> await this._jsonEditingService.write(this._environmentService.argvResource, [{ path: ['password-store'], value: PasswordStoreCLIOption.basic }], true); </ins> this.reinitialize(); } };


private _responsePendingAudioCue: IDisposable | undefined; private _hasReceivedRequest: boolean = false; private _runOnceScheduler: RunOnceScheduler; <ins> private _lastResponse: string | undefined; </ins> constructor(@IAudioCueService private readonly _audioCueService: IAudioCueService) { super();


const isPanelChat = typeof response !== 'string'; this._responsePendingAudioCue?.dispose(); this._runOnceScheduler?.cancel(); <ins> if (this._lastResponse === response?.toString()) { return; } this._lastResponse = response?.toString(); </ins> this._audioCueService.playAudioCue(AudioCue.chatResponseReceived, true); this._hasReceivedRequest = false; if (!response) {


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


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


import { DisposableStore } from 'vs/base/common/lifecycle'; import { CellUri } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { disposableTimeout } from 'vs/base/common/async'; <del> import { IPaneCompositePartService } from 'vs/workbench/services/panecomposite/browser/panecomposite'; import { ViewContainerLocation } from 'vs/workbench/common/views'; </del> import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace'; import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil'; import { isEmptyObject } from 'vs/base/common/types'; import { PLAINTEXT_LANGUAGE_ID } from 'vs/editor/common/languages/modesRegistry'; <del> type FileExtensionSuggestionClassification = { owner: 'sandy081'; comment: 'Response information when a file based reccommendation is suggested'; userReaction: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'User reaction after showing the recommendation prompt. Eg., install, cancel, show, neverShowAgain' }; fileExtension: { classification: 'PublicNonPersonalData'; purpose: 'FeatureInsight'; comment: 'Extension of the file for which an extension is being recommended.' }; }; </del> const promptedRecommendationsStorageKey = 'fileBasedRecommendations/promptedRecommendations'; <del> const promptedFileExtensionsStorageKey = 'fileBasedRecommendations/promptedFileExtensions'; </del> const recommendationsStorageKey = 'extensionsAssistant/recommendations'; <del> const searchMarketplace = localize('searchMarketplace', "Search Marketplace"); </del> const milliSecondsInADay = 1000 * 60 * 60 * 24; export class FileBasedRecommendations extends ExtensionRecommendations {


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


constructor( @IExtensionsWorkbenchService private readonly extensionsWorkbenchService: IExtensionsWorkbenchService, <del> @IPaneCompositePartService private readonly paneCompositeService: IPaneCompositePartService, </del> @IModelService private readonly modelService: IModelService, @ILanguageService private readonly languageService: ILanguageService, @IProductService productService: IProductService, <del> @INotificationService private readonly notificationService: INotificationService, @ITelemetryService private readonly telemetryService: ITelemetryService, </del> @IStorageService private readonly storageService: IStorageService, @IExtensionRecommendationNotificationService private readonly extensionRecommendationNotificationService: IExtensionRecommendationNotificationService, @IExtensionIgnoredRecommendationsService private readonly extensionIgnoredRecommendationsService: IExtensionIgnoredRecommendationsService, @IWorkspaceContextService private readonly workspaceContextService: IWorkspaceContextService, <del> @IExtensionManagementServerService private readonly extensionManagementServerService: IExtensionManagementServerService, </del> ) { super(); this.fileOpenRecommendations = {};


} // re-schedule this bit of the operation to be off the critical path - in case glob-match is slow <del> this._register(disposableTimeout(() => this.promptRecommendations(uri, model), 0)); } private promptRecommendations(uri: URI, model: ITextModel): void { if (this.promptImportantRecommendations(uri, model)) { return; } const fileExtension = extname(uri).toLowerCase(); if (!this.processedFileExtensions.includes(fileExtension)) { this.processedFileExtensions.push(fileExtension); this.promptRecommendedExtensionForFileExtension(uri, fileExtension); } </del> <ins> this._register(disposableTimeout(() => this.promptImportantRecommendations(uri, model), 0)); </ins> } /** * Prompt the user to either install the recommended extension for the file type in the current editor model * or prompt to search the marketplace if it has extensions that can support the file type */ <del> private promptImportantRecommendations(uri: URI, model: ITextModel, extensionRecommendations?: IStringDictionary<IFileOpenCondition[]>): boolean { </del> <ins> private promptImportantRecommendations(uri: URI, model: ITextModel, extensionRecommendations?: IStringDictionary<IFileOpenCondition[]>): void { </ins> const pattern = extname(uri).toLowerCase(); extensionRecommendations = extensionRecommendations ?? this.recommendationsByPattern.get(pattern) ?? this.fileOpenRecommendations; const extensionRecommendationEntries = Object.entries(extensionRecommendations); if (extensionRecommendationEntries.length === 0) { <del> return false; </del> <ins> return; </ins> } const processedPathGlobs = new Map<string, boolean>();


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


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


codeEditor = codeEditorService.getActiveCodeEditor()!; } accessibleViewService.show(instantiationService.createInstance(AccessibilityHelpProvider, codeEditor)); <del> })); </del> <ins> }, EditorContextKeys.focus)); </ins> } }


return this._view; } <del> const toolbar = this.instantiationService.createInstance(WorkbenchToolBar, this.toolbarContainer, { </del> <ins> const toolbar = this._register(this.instantiationService.createInstance(WorkbenchToolBar, this.toolbarContainer, { </ins> actionViewItemProvider: action => { return createActionViewItem(this.instantiationService, action); }, renderDropdownAsChildElement: true <del> }); </del> <ins> })); </ins> const deleteToolbar = this._register(this.instantiationService.invokeFunction(accessor => createDeleteToolbar(accessor, this.toolbarContainer, 'cell-delete-toolbar'))); if (model.deleteActions.primary.length !== 0 || model.deleteActions.secondary.length !== 0) {


debug!(self.logger, "Starting server with command... {:?}", cmd); <ins> // On Windows spawning a code-server binary will run cmd.exe /c C:pathtocode-server.cmd... // This spawns a cmd.exe window for the user, which if they close will kill the code-server process // and disconnect the tunnel. To prevent this, pass the CREATE_NO_WINDOW flag to the Command // only on Windows. // Original issue: https://github.com/microsoft/vscode/issues/184058 // Partial fix: https://github.com/microsoft/vscode/pull/184621 #[cfg(target_os = "windows")] let cmd = cmd.creation_flags(winapi::um::winbase::CREATE_NO_WINDOW); </ins> let child = cmd .stderr(std::process::Stdio::piped()) .stdout(std::process::Stdio::piped())


get disableWorkspaceTrust(): boolean { return !!this.args['disable-workspace-trust']; } @memoize <ins> get disableKeytar(): boolean { return !!this.args['disable-keytar']; } @memoize </ins> get policyFile(): URI | undefined { if (this.args['__enable-file-policy']) { const vscodePortable = env['VSCODE_PORTABLE'];


get disableUpdates(): boolean { return !!this.args['disable-updates']; } @memoize <del> get disableKeytar(): boolean { return !!this.args['disable-keytar']; } @memoize </del> get crossOriginIsolated(): boolean { return !!this.args['enable-coi']; } @memoize


private async initialize(): Promise<IStorageService> { let storageService; if (!this._useInMemoryStorage && await this._encryptionService.isEncryptionAvailable()) { <ins> this._logService.trace(`[SecretStorageService] Encryption is available, using persisted storage`); </ins> this._type = 'persisted'; storageService = this._storageService; } else {


this._sequencer.queue(key, async () => { await this.resolvedStorageService; <del> if (this.type !== 'persisted') { </del> <ins> if (this.type !== 'persisted' && !this._environmentService.disableKeytar) { </ins> this._logService.trace('[NativeSecretStorageService] Notifying user that secrets are not being stored on disk.'); await this.notifyOfNoEncryptionOnce(); }


} })); <ins> // Title Menu changes this._register(this.titleService.onDidChangeCommandCenterVisibility(() => this.doUpdateLayoutConfiguration())); </ins> // Fullscreen changes this._register(onDidChangeFullscreen(() => this.onFullscreenChanged()));


this._register(this.titleService.onMenubarVisibilityChange(visible => this.onMenubarToggled(visible))); } <del> // Title Menu changes this._register(this.titleService.onDidChangeCommandCenterVisibility(() => this.layout())); </del> // Theme changes this._register(this.themeService.onDidColorThemeChange(() => this.updateStyles()));


private _revealInViewWithMinimalScrolling(viewIndex: number, firstLine?: boolean) { const firstIndex = this.view.firstVisibleIndex; <del> if (viewIndex <= firstIndex) { </del> <ins> const elementHeight = this.view.elementHeight(viewIndex); if (viewIndex <= firstIndex || elementHeight >= this.view.renderHeight) { </ins> this._revealInternal(viewIndex, true, CellRevealPosition.Top, firstLine); } else { this._revealInternal(viewIndex, true, CellRevealPosition.Bottom, firstLine);


{ "name": "code-oss-dev", "version": "1.82.0", <del> "distro": "49cc0fbc0a8e222bcce2a7c3bf62e0d23f20d258", </del> <ins> "distro": "2100ad274ed566f978bb917f327b3d99f95d59f2", </ins> "author": { "name": "Microsoft Corporation" },


disturl "https://nodejs.org/dist" target "18.15.0" <del> ms_build_id "223745" </del> <ins> ms_build_id "229541" </ins> runtime "node" build_from_source "true"


) { super(); this._register(Registry.as<IViewsRegistry>(Extensions.ViewsRegistry).registerViewWelcomeContent(TUNNEL_VIEW_ID, { <del> content: `No forwarded ports. Forward a port to access your running services locally.n[Forward a Port](command:${ForwardPortAction.INLINE_ID})`, </del> <ins> content: this.environmentService.remoteAuthority ? nls.localize('remoteNoPorts', "No forwarded ports. Forward a port to access your running services locally.n[Forward a Port]({0})", `command:${ForwardPortAction.INLINE_ID}`) : nls.localize('noRemoteNoPorts', "No forwarded ports. Forward a port to access your locally running services over the internet.n[Forward a Port]({0})", `command:${ForwardPortAction.INLINE_ID}`), </ins> })); this.enableBadgeAndStatusBar(); this.enableForwardedPortsView();


} # Set IsWindows property <del> [Console]::Write("$([char]0x1b)]633;P;IsWindows=$($IsWindows)`a") </del> <ins> if ($PSVersionTable.PSVersion -lt "6.0") { # Windows PowerShell is only available on Windows [Console]::Write("$([char]0x1b)]633;P;IsWindows=$true`a") } else { [Console]::Write("$([char]0x1b)]633;P;IsWindows=$IsWindows`a") } </ins> # Set always on key handlers which map to default VS Code keybindings function Set-MappedKeyHandler {


readonly raw: RawXtermTerminal; private _core: IXtermCore; private static _suggestedRendererType: 'canvas' | 'dom' | undefined = undefined; <ins> private static _checkedWebglCompatible = false; </ins> private _attached?: { container: HTMLElement; options: IXtermAttachToElementOptions }; private _isPhysicalMouseWheel = MouseWheelClassifier.INSTANCE.isPhysicalMouseWheel();


if (!this.raw.element || this._webglAddon) { return; } <ins> // Check if the the WebGL renderer is compatible with xterm.js: // - https://github.com/microsoft/vscode/issues/190195 // - https://github.com/xtermjs/xterm.js/issues/4665 // - https://bugs.chromium.org/p/chromium/issues/detail?id=1476475 if (!XtermTerminal._checkedWebglCompatible) { XtermTerminal._checkedWebglCompatible = true; const checkCanvas = document.createElement('canvas'); const checkGl = checkCanvas.getContext('webgl2'); const debugInfo = checkGl?.getExtension('WEBGL_debug_renderer_info'); if (checkGl && debugInfo) { const renderer = checkGl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL); if (renderer.startsWith('ANGLE (Google, Vulkan 1.3.0 (SwiftShader Device (Subzero)')) { this._disableWebglForThisSession(); return; } } } </ins> const Addon = await this._getWebglAddonConstructor(); this._webglAddon = new Addon(); this._disposeOfCanvasRenderer();


if (!neverMeasureRenderTime && this._configHelper.config.gpuAcceleration !== 'off') { this._measureRenderTime(); } <del> XtermTerminal._suggestedRendererType = 'canvas'; this._disposeOfWebglRenderer(); this._enableCanvasRenderer(); </del> <ins> this._disableWebglForThisSession(); </ins> } } <ins> private _disableWebglForThisSession() { XtermTerminal._suggestedRendererType = 'canvas'; this._disposeOfWebglRenderer(); this._enableCanvasRenderer(); } </ins> private async _enableCanvasRenderer(): Promise<void> { if (!this.raw.element || this._canvasAddon) { return;


}); suite('renderers', () => { <del> test('should re-evaluate gpu acceleration auto when the setting is changed', async () => { </del> <ins> // This is skipped until the webgl renderer bug is fixed in Chromium // https://bugs.chromium.org/p/chromium/issues/detail?id=1476475 test.skip('should re-evaluate gpu acceleration auto when the setting is changed', async () => { </ins> // Check initial state strictEqual(TestWebglAddon.isEnabled, false);


*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> import { Disposable, MutableDisposable } from 'vs/base/common/lifecycle'; </del> <ins> import { Disposable, DisposableStore, MutableDisposable } from 'vs/base/common/lifecycle'; </ins> import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility'; import { ITerminalCapabilityStore, TerminalCapability } from 'vs/platform/terminal/common/capabilities/capabilities'; import { ITerminalLogService } from 'vs/platform/terminal/common/terminal'; import type { Terminal, ITerminalAddon } from 'xterm'; <ins> import { debounce } from 'vs/base/common/decorators'; import { addDisposableListener } from 'vs/base/browser/dom'; </ins> export interface ITextAreaData { content: string;


export class TextAreaSyncAddon extends Disposable implements ITerminalAddon { private _terminal: Terminal | undefined; <del> private _onCursorMoveListener = this._register(new MutableDisposable()); </del> <ins> private _listeners = this._register(new MutableDisposable<DisposableStore>()); private _currentCommand: string | undefined; private _cursorX: number | undefined; </ins> activate(terminal: Terminal): void { this._terminal = terminal; if (this._accessibilityService.isScreenReaderOptimized()) { <del> this._onCursorMoveListener.value = this._terminal.onCursorMove(() => this._refreshTextArea()); </del> <ins> this._registerSyncListeners(); </ins> } }


) { super(); this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => { <del> if (this._accessibilityService.isScreenReaderOptimized() && this._terminal) { this._refreshTextArea(); this._onCursorMoveListener.value = this._terminal.onCursorMove(() => this._refreshTextArea()); </del> <ins> if (this._accessibilityService.isScreenReaderOptimized()) { this._syncTextArea(); this._registerSyncListeners(); </ins> } else { <del> this._onCursorMoveListener.clear(); </del> <ins> this._listeners.clear(); </ins> } })); } <del> private _refreshTextArea(focusChanged?: boolean): void { </del> <ins> private _registerSyncListeners(): void { if (this._accessibilityService.isScreenReaderOptimized() && this._terminal?.textarea) { this._listeners.value = new DisposableStore(); this._listeners.value.add(this._terminal.onCursorMove(() => this._syncTextArea())); this._listeners.value.add(this._terminal.onData(() => this._syncTextArea())); this._listeners.value.add(addDisposableListener(this._terminal.textarea, 'focus', () => this._syncTextArea())); } } @debounce(50) private _syncTextArea(): void { this._logService.debug('TextAreaSyncAddon#syncTextArea'); const textArea = this._terminal?.textarea; if (!textArea) { this._logService.debug(`TextAreaSyncAddon#syncTextArea: no textarea`); return; } this._updateCommandAndCursor(); if (this._currentCommand !== textArea.value) { textArea.value = this._currentCommand || ''; this._logService.debug(`TextAreaSyncAddon#syncTextArea: text changed to "${this._currentCommand}"`); } else if (!this._currentCommand) { textArea.value = ''; this._logService.debug(`TextAreaSyncAddon#syncTextArea: text cleared`); } if (this._cursorX !== textArea.selectionStart) { textArea.selectionStart = this._cursorX ?? 0; textArea.selectionEnd = this._cursorX ?? 0; this._logService.debug(`TextAreaSyncAddon#syncTextArea: selection start/end changed to ${this._cursorX}`); } } private _updateCommandAndCursor(): void { </ins> if (!this._terminal) { return; } <del> this._logService.debug('TextAreaSyncAddon#refreshTextArea'); </del> const commandCapability = this._capabilities.get(TerminalCapability.CommandDetection); const currentCommand = commandCapability?.currentCommand; if (!currentCommand) { <del> this._logService.debug(`TextAreaSyncAddon#refreshTextArea: no currentCommand`); </del> <ins> this._logService.debug(`TextAreaSyncAddon#updateCommandAndCursor: no current command`); </ins> return; } const buffer = this._terminal.buffer.active; const line = buffer.getLine(buffer.cursorY)?.translateToString(true); <del> let commandStartX: number | undefined; </del> if (!line) { <del> this._logService.debug(`TextAreaSyncAddon#refreshTextArea: no line`); </del> <ins> this._logService.debug(`TextAreaSyncAddon#updateCommandAndCursor: no line`); </ins> return; } <del> let content: string | undefined; if (currentCommand.commandStartX) { </del> <ins> if (currentCommand.commandStartX !== undefined) { </ins> // Left prompt <del> content = line.substring(currentCommand.commandStartX); commandStartX = currentCommand.commandStartX; } else if (currentCommand.commandRightPromptStartX) { </del> <ins> this._currentCommand = line.substring(currentCommand.commandStartX); this._cursorX = buffer.cursorX - currentCommand.commandStartX; } else if (currentCommand.commandRightPromptStartX !== undefined) { </ins> // Right prompt <del> content = line.substring(0, currentCommand.commandRightPromptStartX); commandStartX = 0; } if (!content) { this._logService.debug(`TextAreaSyncAddon#refreshTextArea: no content`); return; } if (commandStartX === undefined) { this._logService.debug(`TextAreaSyncAddon#refreshTextArea: no commandStartX`); return; } const textArea = this._terminal.textarea; if (!textArea) { this._logService.debug(`TextAreaSyncAddon#refreshTextArea: no textarea`); return; } this._logService.debug(`TextAreaSyncAddon#refreshTextArea: content is "${content}"`); this._logService.debug(`TextAreaSyncAddon#refreshTextArea: textContent is "${textArea.textContent}"`); if (focusChanged || content !== textArea.textContent) { textArea.textContent = content; this._logService.debug(`TextAreaSyncAddon#refreshTextArea: textContent changed to "${content}"`); } const cursorX = buffer.cursorX - commandStartX; this._logService.debug(`TextAreaSyncAddon#refreshTextArea: cursorX is ${cursorX}`); this._logService.debug(`TextAreaSyncAddon#refreshTextArea: selectionStart is ${textArea.selectionStart}`); if (focusChanged || cursorX !== textArea.selectionStart) { textArea.selectionStart = cursorX; textArea.selectionEnd = cursorX; this._logService.debug(`TextAreaSyncAddon#refreshTextArea: selectionStart changed to ${cursorX}`); </del> <ins> this._currentCommand = line.substring(0, currentCommand.commandRightPromptStartX); this._cursorX = buffer.cursorX; } else { this._currentCommand = undefined; this._cursorX = undefined; this._logService.debug(`TextAreaSyncAddon#updateCommandAndCursor: neither commandStartX nor commandRightPromptStartX`); </ins> } <del> // TODO: cursorY? </del> } }


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


getScoped(scope: EnvironmentVariableScope): EnvironmentVariableCollection; } <del> export type EnvironmentVariableScope = { </del> <ins> /** * The scope object to which the environment variable collection applies. */ export interface EnvironmentVariableScope { </ins> /** * Any specific workspace folder to get collection for. */ workspaceFolder?: WorkspaceFolder; <del> }; </del> <ins> } </ins> /** * A location in the editor at which progress information can be shown. It depends on the


if (isNonEmptyArray(notification.actions && notification.actions.secondary)) { actions++; // secondary actions } <del> this.offsetHelper.style.width = `${450 /* notifications container width */ - (10 /* padding */ + 26 /* severity icon */ + (actions * (24 + 8)) /* 24px (+8px padding) per action */ - 4 /* 4px less padding for last action */)}px`; </del> <ins> this.offsetHelper.style.width = `${450 /* notifications container width */ - (10 /* padding */ + 30 /* severity icon */ + (actions * 30) /* actions */ - (Math.max(actions - 1, 0) * 4) /* less padding for actions > 1 */)}px`; </ins> // Render message into offset helper const renderedMessage = NotificationMessageRenderer.render(notification.message);


pinned, selection, revealIfVisible: true, <del> indexedCellOptions: element instanceof MatchInNotebook ? { index: element.cellIndex, selection: element.range() } : undefined, </del> }; try {


disturl="https://electronjs.org/headers" target="30.5.1" <del> ms_build_id="10262041" </del> <ins> ms_build_id="10306386" </ins> runtime="electron" build_from_source="true" legacy-peer-deps="true"


{ "name": "code-oss-dev", "version": "1.95.0", <del> "distro": "350f0404ef17accb38b1359e82886738870a7377", </del> <ins> "distro": "1f05cd9b265f2477905f0b7688a66cfb2c6061f5", </ins> "author": { "name": "Microsoft Corporation" },


} None => SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), args.port), }; <ins> let builder = Server::try_bind(&addr).map_err(CodeError::CouldNotListenOnInterface)?; </ins> let mut listening = format!("Web UI available at http://{}", addr); if let Some(ct) = args.connection_token {


} ctx.log.result(listening); <del> Server::bind(&addr) </del> <ins> builder </ins> .serve(make_service_fn(|_| make_svc())) .with_graceful_shutdown(async { let _ = shutdown.wait().await;


.test-output-peek-tree { color: var(--vscode-editor-foreground); <ins> border-left: 1px solid var(--vscode-panelSection-border); </ins> } .test-output-peek-tree .monaco-list-row .monaco-action-bar,


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


terminal.xterm.write(chunk.buffer, () => pendingWrites.value--); } } else { <ins> didWriteData = true; </ins> this.writeNotice(terminal, localize('runNoOutputForPast', 'Test output is only available for new test runs.')); }


} private writeNotice(terminal: IDetachedTerminalInstance, str: string) { <del> terminal.xterm.write(`x1b[2m${str}x1b[0m`); </del> <ins> terminal.xterm.write(formatMessageForTerminal(str)); </ins> } private attachTerminalToDom(terminal: IDetachedTerminalInstance) {


})); if (this._dimension) { <del> this._list.layout(this._dimension.height, this._dimension.width); </del> <ins> this._list.layout(this.getBodyHeight(this._dimension.height), this._dimension.width); </ins> } else { this._list.layout(); }


return this._scrollBeyondLastLine && !this.isEmbedded; } <ins> private getBodyHeight(dimensionHeight: number) { return Math.max(dimensionHeight - (this._notebookTopToolbar?.useGlobalToolbar ? /** Toolbar height */ 26 : 0), 0); } </ins> layout(dimension: DOM.Dimension, shadowElement?: HTMLElement, position?: DOM.IDomPosition): void { if (!shadowElement && this._shadowElementViewInfo === null) { this._dimension = dimension;


this._dimension = dimension; this._position = position; <del> const newBodyHeight = Math.max(dimension.height - (this._notebookTopToolbar?.useGlobalToolbar ? /** Toolbar height */ 26 : 0), 0); </del> <ins> const newBodyHeight = this.getBodyHeight(dimension.height); </ins> DOM.size(this._body, dimension.width, newBodyHeight); const topInserToolbarHeight = this._notebookOptions.computeTopInsertToolbarHeight(this.viewModel?.viewType);


} if (this._cursorX !== textArea.selectionStart) { <del> textArea.selectionStart = this._cursorX ?? 0; textArea.selectionEnd = this._cursorX ?? 0; this._logService.debug(`TextAreaSyncAddon#syncTextArea: selection start/end changed to ${this._cursorX}`); </del> <ins> const selection = !this._cursorX || this._cursorX < 0 ? 0 : this._cursorX; textArea.selectionStart = selection; textArea.selectionEnd = selection; this._logService.debug(`TextAreaSyncAddon#syncTextArea: selection start/end changed to ${selection}`); </ins> } }


private _dimensions: ITerminalDimensions; private __isCommandStorageDisabled: boolean = false; private _handleCommandStartOptions?: IHandleCommandOptions; <ins> private _commandStartWindowsPromise?: Promise<void>; </ins> get commands(): readonly ITerminalCommand[] { return this._commands; } get executingCommand(): string | undefined { return this._currentCommand.command; }


return; } if (this._isWindowsPty) { <del> this._handleCommandStartWindows(); </del> <ins> this._commandStartWindowsPromise = this._handleCommandStartWindows(); </ins> return; } this._currentCommand.commandStartX = this._terminal.buffer.active.cursorX;


this._logService.debug('CommandDetectionCapability#handleCommandStart', this._currentCommand.commandStartX, this._currentCommand.commandStartMarker?.line); } <del> private _handleCommandStartWindows(): void { </del> <ins> private async _handleCommandStartWindows(): Promise<void> { </ins> this._currentCommand.commandStartX = this._terminal.buffer.active.cursorX; // On Windows track all cursor movements after the command start sequence this._commandMarkers.length = 0; <del> // HACK: Fire command started on the following frame on Windows to allow the cursor // position to update as conpty often prints the sequence on a different line to the // actual line the command started on. timeout(0).then(() => { if (!this._currentCommand.commandExecutedMarker) { this._onCursorMoveListener = this._terminal.onCursorMove(() => { if (this._commandMarkers.length === 0 || this._commandMarkers[this._commandMarkers.length - 1].line !== this._terminal.buffer.active.cursorY) { const marker = this._terminal.registerMarker(0); if (marker) { this._commandMarkers.push(marker); } } }); </del> <ins> const lastCommand = this.commands.at(-1); function cursorOnCorrectLine(terminal: Terminal): boolean { if (!lastCommand) { return false; </ins> } <del> this._currentCommand.commandStartMarker = this._terminal.registerMarker(0); if (this._currentCommand.commandStartMarker) { const line = this._terminal.buffer.active.getLine(this._currentCommand.commandStartMarker.line); if (line) { this._currentCommand.commandStartLineContent = line.translateToString(true); </del> <ins> const cursorYAbsolute = terminal.buffer.active.baseY + terminal.buffer.active.cursorY; // If the cursor position is within the last command, we should poll. const lastCommandYAbsolute = (lastCommand.endMarker ? lastCommand.endMarker.line : lastCommand.marker?.line) ?? -1; return cursorYAbsolute > lastCommandYAbsolute; } function lineIsPrompt(terminal: Terminal): boolean { const line = terminal.buffer.active.getLine(terminal.buffer.active.baseY + terminal.buffer.active.cursorY); if (!line) { return false; } // TODO: fine tune prompt regex to accomodate for unique configurtions. return line.translateToString(true)?.match(/^(PS.+>)|([A-Z]:.*>)/) !== null; } // Conpty could have the wrong cursor position at this point. if (!cursorOnCorrectLine(this._terminal) || !lineIsPrompt(this._terminal)) { // Poll for 200ms until the cursor position is correct. for (let i = 0; i < 20; i++) { await timeout(10); if (cursorOnCorrectLine(this._terminal) && lineIsPrompt(this._terminal)) { this._logService.debug('CommandDetectionCapability#_handleCommandStartWindows polling attempts required: ', i + 1); break; </ins> } } <del> this._onCommandStarted.fire({ marker: this._currentCommand.commandStartMarker } as ITerminalCommand); this._logService.debug('CommandDetectionCapability#_handleCommandStartWindows', this._currentCommand.commandStartX, this._currentCommand.commandStartMarker?.line); }); </del> <ins> } else { // HACK: Fire command started on the following frame on Windows to allow the cursor // position to update as conpty often prints the sequence on a different line to the // actual line the command started on. await timeout(0); } if (!this._currentCommand.commandExecutedMarker) { this._onCursorMoveListener = this._terminal.onCursorMove(() => { if (this._commandMarkers.length === 0 || this._commandMarkers[this._commandMarkers.length - 1].line !== this._terminal.buffer.active.cursorY) { const marker = this._terminal.registerMarker(0); if (marker) { this._commandMarkers.push(marker); } } }); } this._currentCommand.commandStartMarker = this._terminal.registerMarker(0); if (this._currentCommand.commandStartMarker) { const line = this._terminal.buffer.active.getLine(this._currentCommand.commandStartMarker.line); if (line) { this._currentCommand.commandStartLineContent = line.translateToString(true); } } this._onCommandStarted.fire({ marker: this._currentCommand.commandStartMarker } as ITerminalCommand); this._logService.debug('CommandDetectionCapability#_handleCommandStartWindows', this._currentCommand.commandStartX, this._currentCommand.commandStartMarker?.line); </ins> } handleGenericCommand(options?: IHandleCommandOptions): void {


handleCommandExecuted(options?: IHandleCommandOptions): void { if (this._isWindowsPty) { <del> this._handleCommandExecutedWindows(); </del> <ins> this._commandStartWindowsPromise?.then(() => this._handleCommandExecutedWindows()); </ins> return; }


handleCommandFinished(exitCode: number | undefined, options?: IHandleCommandOptions): void { if (this._isWindowsPty) { <del> this._preHandleCommandFinishedWindows(); </del> <ins> this._commandStartWindowsPromise?.then(() => this._preHandleCommandFinishedWindows()); </ins> } this._currentCommand.commandFinishedMarker = options?.marker || this._terminal.registerMarker(0);


return range; } <del> return decorations[0].getActiveRange() ?? undefined; </del> <ins> return (decorations.length > 0 ? (decorations[0].getActiveRange() ?? undefined) : undefined); </ins> } public dispose(): void {


@IKeybindingService private _keybindingService: IKeybindingService, @IInstantiationService private _instaService: IInstantiationService, ) { <del> super(undefined, _submenu.actions[0], options); </del> <ins> super(undefined, _submenu.actions.find(action => action.id === 'workbench.action.quickOpenWithModes') ?? _submenu.actions[0], options); </ins> } override render(container: HTMLElement): void {


}); <ins> const CONTEXT_TOOLBAR_COMMAND_CENTER = ContextKeyExpr.equals('config.debug.toolBarLocation', 'commandCenter'); </ins> MenuRegistry.appendMenuItem(MenuId.CommandCenterCenter, { submenu: MenuId.DebugToolBar, title: 'Debug', icon: Codicon.debug, order: 1, <del> when: ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, ContextKeyExpr.equals('config.debug.toolBarLocation', 'commandCenter')) </del> <ins> when: ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, CONTEXT_TOOLBAR_COMMAND_CENTER) </ins> }); registerDebugToolBarItem(CONTINUE_ID, CONTINUE_LABEL, 10, icons.debugContinue, CONTEXT_DEBUG_STATE.isEqualTo('stopped'));


registerDebugToolBarItem(RESTART_SESSION_ID, RESTART_LABEL, 60, icons.debugRestart); registerDebugToolBarItem(STEP_BACK_ID, localize('stepBackDebug', "Step Back"), 50, icons.debugStepBack, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_DEBUG_STATE.isEqualTo('stopped')); registerDebugToolBarItem(REVERSE_CONTINUE_ID, localize('reverseContinue', "Reverse"), 55, icons.debugReverseContinue, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_DEBUG_STATE.isEqualTo('stopped')); <del> registerDebugToolBarItem(FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, 100, Codicon.listTree, CONTEXT_MULTI_SESSION_DEBUG); </del> <ins> registerDebugToolBarItem(FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, 100, Codicon.listTree, ContextKeyExpr.and(CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_TOOLBAR_COMMAND_CENTER.negate())); </ins> MenuRegistry.appendMenuItem(MenuId.DebugToolBarStop, { group: 'navigation',


Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({ ...editorConfigurationBaseNode, properties: { <del> 'editor.codeActionWidget.includeNearbyQuickfixes': { </del> <ins> 'editor.codeActionWidget.includeNearbyQuickFixes': { </ins> type: 'boolean', scope: ConfigurationScope.LANGUAGE_OVERRIDABLE, <del> description: nls.localize('includeNearbyQuickfixes', "Enable/disable showing nearest Quick Fix within a line when not currently on a diagnostic."), </del> <ins> description: nls.localize('includeNearbyQuickFixes', "Enable/disable showing nearest Quick Fix within a line when not currently on a diagnostic."), </ins> default: true, }, }


const currPosition = trigger.selection.getPosition(); let trackedPosition = currPosition; let distance = Number.MAX_VALUE; <del> let toBeModified = false; </del> <ins> const currentActions = [...codeActionSet.validActions]; </ins> for (const marker of allMarkers) { const col = marker.endColumn;


const startRow = marker.startLineNumber; // Found quickfix on the same line and check relative distance to other markers <del> if ((row === currPosition.lineNumber || startRow === currPosition.lineNumber) && Math.abs(currPosition.column - col) < distance) { distance = Math.abs(currPosition.column - col); toBeModified = true; </del> <ins> if ((row === currPosition.lineNumber || startRow === currPosition.lineNumber)) { </ins> trackedPosition = new Position(row, col); <ins> const newCodeActionTrigger: CodeActionTrigger = { type: trigger.trigger.type, triggerAction: trigger.trigger.triggerAction, filter: { include: trigger.trigger.filter?.include ? trigger.trigger.filter?.include : CodeActionKind.QuickFix }, autoApply: trigger.trigger.autoApply, context: { notAvailableMessage: trigger.trigger.context?.notAvailableMessage || '', position: trackedPosition } }; const selectionAsPosition = new Selection(trackedPosition.lineNumber, trackedPosition.column, trackedPosition.lineNumber, trackedPosition.column); const actionsAtMarker = await getCodeActions(this._registry, model, selectionAsPosition, newCodeActionTrigger, Progress.None, token); if (actionsAtMarker.validActions.length !== 0) { for (const action of actionsAtMarker.validActions) { action.highlightRange = action.action.isPreferred; } // Already filtered through to only get quickfixes, so no need to filter again. if (Math.abs(currPosition.column - col) < distance) { currentActions.unshift(...actionsAtMarker.validActions); } else { currentActions.push(...actionsAtMarker.validActions); } } distance = Math.abs(currPosition.column - col); </ins> } } <ins> currentActions.filter((action, index, self) => self.findIndex((a) => a.action.title === action.action.title) === index); currentActions.sort((a, b) => { if (a.action.isPreferred && !b.action.isPreferred) { return -1; } else if (!a.action.isPreferred && b.action.isPreferred) { return 1; } else { return 0; } }); </ins> // Only retriggers if actually found quickfix on the same line as cursor <del> if (toBeModified) { const newCodeActionTrigger: CodeActionTrigger = { type: trigger.trigger.type, triggerAction: trigger.trigger.triggerAction, filter: { include: trigger.trigger.filter?.include ? trigger.trigger.filter?.include : CodeActionKind.QuickFix }, autoApply: trigger.trigger.autoApply, context: { notAvailableMessage: trigger.trigger.context?.notAvailableMessage || '', position: trackedPosition } }; const selectionAsPosition = new Selection(trackedPosition.lineNumber, trackedPosition.column, trackedPosition.lineNumber, trackedPosition.column); const actionsAtMarker = await getCodeActions(this._registry, model, selectionAsPosition, newCodeActionTrigger, Progress.None, token); const currentActions = [...codeActionSet.validActions]; if (actionsAtMarker.validActions.length !== 0) { actionsAtMarker.validActions.forEach(action => { action.highlightRange = action.action.isPreferred; }); // Already filtered through to only get quickfixes, so no need to filter again. currentActions.push(...actionsAtMarker.validActions); } return { validActions: currentActions, allActions: codeActionSet.allActions, documentation: codeActionSet.documentation, hasAutoFix: codeActionSet.hasAutoFix, dispose: () => { codeActionSet.dispose(); } }; } </del> <ins> return { validActions: currentActions, allActions: codeActionSet.allActions, documentation: codeActionSet.documentation, hasAutoFix: codeActionSet.hasAutoFix, dispose: () => { codeActionSet.dispose(); } }; </ins> } } } // temporarilly hiding here as this is enabled/disabled behind a setting. return getCodeActions(this._registry, model, trigger.selection, trigger.trigger, Progress.None, token); }); if (trigger.trigger.type === CodeActionTriggerType.Invoke) { this._progressService?.showWhile(actions, 250); }


return { ahead: Number(ahead) || 0, behind: Number(behind) || 0 }; } <ins> async revParse(ref: string): Promise<string | undefined> { try { const result = await this.exec(['rev-parse', ref]); if (result.stderr) { return undefined; } return result.stdout.trim(); } catch (err) { return undefined; } } </ins> async updateSubmodules(paths: string[]): Promise<void> { const args = ['submodule', 'update'];


} const optionsRef = options.limit.id; <ins> const historyItemGroupIdRef = await this.repository.revParse(historyItemGroupId) ?? ''; </ins> const [commits, summary] = await Promise.all([ <del> this.repository.log({ range: `${optionsRef}..${historyItemGroupId}`, sortByAuthorDate: true }), this.getSummaryHistoryItem(optionsRef, historyItemGroupId) </del> <ins> this.repository.log({ range: `${optionsRef}..${historyItemGroupIdRef}`, sortByAuthorDate: true }), this.getSummaryHistoryItem(optionsRef, historyItemGroupIdRef) </ins> ]); const historyItems = commits.length === 0 ? [] : [summary];


RevertFiles = 'RevertFiles', RevertFilesNoProgress = 'RevertFilesNoProgress', RevList = 'RevList', <ins> RevParse = 'RevParse', </ins> SetBranchUpstream = 'SetBranchUpstream', Show = 'Show', Stage = 'Stage',


GetBranchOperation | GetBranchesOperation | GetCommitTemplateOperation | GetObjectDetailsOperation | GetRefsOperation | GetRemoteRefsOperation | HashObjectOperation | IgnoreOperation | LogOperation | LogFileOperation | MergeOperation | MergeAbortOperation | MergeBaseOperation | MoveOperation | PostCommitCommandOperation | PullOperation | PushOperation | RemoteOperation | RenameBranchOperation | RemoveOperation | <del> ResetOperation | RebaseOperation | RebaseAbortOperation | RebaseContinueOperation | RevertFilesOperation | RevListOperation | </del> <ins> ResetOperation | RebaseOperation | RebaseAbortOperation | RebaseContinueOperation | RevertFilesOperation | RevListOperation | RevParseOperation | </ins> SetBranchUpstreamOperation | ShowOperation | StageOperation | StatusOperation | StashOperation | SubmoduleUpdateOperation | SyncOperation | TagOperation;


export type RebaseContinueOperation = BaseOperation & { kind: OperationKind.RebaseContinue }; export type RevertFilesOperation = BaseOperation & { kind: OperationKind.RevertFiles }; export type RevListOperation = BaseOperation & { kind: OperationKind.RevList }; <ins> export type RevParseOperation = BaseOperation & { kind: OperationKind.RevParse }; </ins> export type SetBranchUpstreamOperation = BaseOperation & { kind: OperationKind.SetBranchUpstream }; export type ShowOperation = BaseOperation & { kind: OperationKind.Show }; export type StageOperation = BaseOperation & { kind: OperationKind.Stage };


RebaseContinue: { kind: OperationKind.RebaseContinue, blocking: false, readOnly: false, remote: false, retry: false, showProgress: true } as RebaseContinueOperation, RevertFiles: (showProgress: boolean) => ({ kind: OperationKind.RevertFiles, blocking: false, readOnly: false, remote: false, retry: false, showProgress } as RevertFilesOperation), RevList: { kind: OperationKind.RevList, blocking: false, readOnly: true, remote: false, retry: false, showProgress: false } as RevListOperation, <ins> RevParse: { kind: OperationKind.RevParse, blocking: false, readOnly: true, remote: false, retry: false, showProgress: false } as RevParseOperation, </ins> SetBranchUpstream: { kind: OperationKind.SetBranchUpstream, blocking: false, readOnly: false, remote: false, retry: false, showProgress: true } as SetBranchUpstreamOperation, Show: { kind: OperationKind.Show, blocking: false, readOnly: true, remote: false, retry: false, showProgress: false } as ShowOperation, Stage: { kind: OperationKind.Stage, blocking: false, readOnly: false, remote: false, retry: false, showProgress: true } as StageOperation,


return await this.run(Operation.RevList, () => this.repository.getCommitCount(range)); } <ins> async revParse(ref: string): Promise<string | undefined> { return await this.run(Operation.RevParse, () => this.repository.revParse(ref)); } </ins> async reset(treeish: string, hard?: boolean): Promise<void> { await this.run(Operation.Reset, () => this.repository.reset(treeish, hard)); }


'editor.codeActionWidget.includeNearbyQuickfixes': { type: 'boolean', scope: ConfigurationScope.LANGUAGE_OVERRIDABLE, <del> description: nls.localize('includeNearbyQuickfixes', "Enable/disable showing nearest quickfix within a line when not currently on a diagnostic."), default: false, </del> <ins> description: nls.localize('includeNearbyQuickfixes', "Enable/disable showing nearest Quick Fix within a line when not currently on a diagnostic."), default: true, </ins> }, } });


} editor = editor ?? this.editorService.activeTextEditorControl; <del> if (isDiffEditor(editor)) { if (editor.getOriginalEditor().hasTextFocus()) { editor = editor.getOriginalEditor(); } else { editor = editor.getModifiedEditor(); } } </del> if (!editor) { return null;


return undefined; } <del> export function getSelectionTextFromEditor(allowUnselectedWord: boolean, editor: IEditor): string | null { </del> <ins> export function getSelectionTextFromEditor(allowUnselectedWord: boolean, activeEditor: IEditor): string | null { let editor = activeEditor; if (isDiffEditor(editor)) { if (editor.getOriginalEditor().hasTextFocus()) { editor = editor.getOriginalEditor(); } else { editor = editor.getModifiedEditor(); } } </ins> if (!isCodeEditor(editor) || !editor.hasModel()) { return null;


import { Mime, mediaMimes } from '../../util/mimes'; import { Schemes } from '../../util/schemes'; import { createEditForMediaFiles, tryGetUriListSnippet } from './shared'; <ins> import { getParentDocumentUri } from '../../util/document'; </ins> class ResourceDropProvider implements vscode.DocumentDropEditProvider {


} private async _getMediaFilesEdit(document: vscode.TextDocument, dataTransfer: vscode.DataTransfer, token: vscode.CancellationToken): Promise<vscode.DocumentDropEdit | undefined> { <del> if (document.uri.scheme === Schemes.untitled) { </del> <ins> if (getParentDocumentUri(document.uri).scheme === Schemes.untitled) { </ins> return; }


import { Mime, mediaMimes } from '../../util/mimes'; import { Schemes } from '../../util/schemes'; import { PasteUrlAsFormattedLink, createEditAddingLinksForUriList, createEditForMediaFiles, getPasteUrlAsFormattedLinkSetting } from './shared'; <ins> import { getParentDocumentUri } from '../../util/document'; </ins> class PasteResourceEditProvider implements vscode.DocumentPasteEditProvider {


} private async _getMediaFilesEdit(document: vscode.TextDocument, dataTransfer: vscode.DataTransfer, token: vscode.CancellationToken): Promise<vscode.DocumentPasteEdit | undefined> { <del> if (document.uri.scheme === Schemes.untitled) { </del> <ins> if (getParentDocumentUri(document.uri).scheme === Schemes.untitled) { </ins> return; }


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


import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService'; import { IOutlineModelService } from 'vs/editor/contrib/documentSymbols/browser/outlineModel'; import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures'; <ins> import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey'; import { accessibilityHelpIsShown, accessibleViewIsShown } from 'vs/workbench/contrib/accessibility/browser/accessibilityConfiguration'; </ins> export class GotoSymbolQuickAccessProvider extends AbstractGotoSymbolQuickAccessProvider {


}, f1: true, keybinding: { <del> when: undefined, </del> <ins> when: ContextKeyExpr.and(accessibleViewIsShown.negate(), accessibilityHelpIsShown.negate()), </ins> weight: KeybindingWeight.WorkbenchContrib, primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyO },


// Windows 32-bit warning if (isWindows && this.environmentService.os.arch === 'ia32') { const message = localize('windows32eolmessage', "You are running {0} 32-bit, which will soon stop receiving updates on Windows. Consider upgrading to the 64-bit build.", this.productService.nameLong); <del> const actions = [{ label: localize('windowseolBannerLearnMore', "Learn More"), href: 'https://aka.ms/vscode-faq-old-windows' }]; this.bannerService.show({ id: 'windows32eol.banner', message, ariaLabel: localize('windowseolarialabel', "{0}. Use navigation keys to access banner actions.", message), actions, icon: Codicon.warning }); </del> this.notificationService.prompt( Severity.Warning,


if (eolReleases.has(majorVersion)) { const message = localize('macoseolmessage', "{0} on {1} will soon stop receiving updates. Consider upgrading your macOS version.", this.productService.nameLong, eolReleases.get(majorVersion)); <del> const actions = [{ label: localize('macoseolBannerLearnMore', "Learn More"), href: 'https://aka.ms/vscode-faq-old-macOS' }]; this.bannerService.show({ id: 'macoseol.banner', message, ariaLabel: localize('macoseolarialabel', "{0}. Use navigation keys to access banner actions.", message), actions, icon: Codicon.warning }); </del> this.notificationService.prompt( Severity.Warning,