return undefined; } <ins> private async getUpstreamBranch(branch: Branch): Promise<Branch | undefined> { if (!branch.upstream) { return undefined; } try { const upstreamBranch = await this.getBranch(`refs/remotes/${branch.upstream.remote}/${branch.upstream.name}`); return upstreamBranch; } catch (err) { this.logger.warn(`Failed to get branch details for 'refs/remotes/${branch.upstream.remote}/${branch.upstream.name}': ${err.message}.`); return undefined; } } </ins> async getRefs(query: RefQuery = {}, cancellationToken?: CancellationToken): Promise<Ref[]> { const config = workspace.getConfiguration('git'); let defaultSort = config.get<'alphabetically' | 'committerdate'>('branchSortOrder');


@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',


} public async $OnDidEndTask(execution: tasks.ITaskExecutionDTO): Promise<void> { <ins> if (!this._taskExecutionPromises.has(execution.id)) { // Event already fired by the main thread // See https://github.com/microsoft/vscode/commit/aaf73920aeae171096d205efb2c58804a32b6846 return; } </ins> const _execution = await this.getTaskExecution(execution); this._taskExecutionPromises.delete(execution.id); this._taskExecutions.delete(execution.id);


if (result) { return result; } <del> const createdResult: Promise<TaskExecutionImpl> = new Promise((resolve, reject) => { function resolvePromiseWithCreatedTask(that: ExtHostTaskBase, execution: tasks.ITaskExecutionDTO, taskToCreate: vscode.Task | types.Task | undefined) { if (!taskToCreate) { reject('Unexpected: Task does not exist.'); } else { resolve(new TaskExecutionImpl(that, execution.id, taskToCreate)); } } if (task) { resolvePromiseWithCreatedTask(this, execution, task); } else { TaskDTO.to(execution.task, this._workspaceProvider, this._providedCustomExecutions2) .then(task => resolvePromiseWithCreatedTask(this, execution, task)); } }); this._taskExecutionPromises.set(execution.id, createdResult); return createdResult.then(executionCreatedResult => { this._taskExecutions.set(execution.id, executionCreatedResult); return executionCreatedResult; }, rejected => { return Promise.reject(rejected); </del> <ins> let executionPromise: Promise<TaskExecutionImpl>; if (!task) { executionPromise = TaskDTO.to(execution.task, this._workspaceProvider, this._providedCustomExecutions2).then(t => { if (!t) { throw new ErrorNoTelemetry('Unexpected: Task does not exist.'); } return new TaskExecutionImpl(this, execution.id, t); }); } else { executionPromise = Promise.resolve(new TaskExecutionImpl(this, execution.id, task)); } this._taskExecutionPromises.set(execution.id, executionPromise); return executionPromise.then(taskExecution => { this._taskExecutions.set(execution.id, taskExecution); return taskExecution; </ins> }); }


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


import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry'; import { Registry } from 'vs/platform/registry/common/platform'; import { InlineChatController } from 'vs/workbench/contrib/inlineChat/browser/inlineChatController'; <del> import { CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_LAST } from 'vs/workbench/contrib/inlineChat/common/inlineChat'; </del> import { INotebookActionContext, INotebookCellActionContext, NotebookAction, NotebookCellAction, NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT, findTargetCellEditor } from 'vs/workbench/contrib/notebook/browser/controller/coreActions'; import { CellEditState } from 'vs/workbench/contrib/notebook/browser/notebookBrowser'; import { CellKind, NOTEBOOK_EDITOR_CURSOR_BOUNDARY } from 'vs/workbench/contrib/notebook/common/notebookCommon';


weight: KeybindingWeight.WorkbenchContrib }, { <del> when: ContextKeyExpr.and( NOTEBOOK_EDITOR_FOCUSED, CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate(), ContextKeyExpr.equals('config.notebook.navigation.allowNavigateToSurroundingCells', true), ContextKeyExpr.and( ContextKeyExpr.has(InputFocusedContextKey), NOTEBOOK_EDITOR_CURSOR_BOUNDARY.notEqualsTo('top'), NOTEBOOK_EDITOR_CURSOR_BOUNDARY.notEqualsTo('none'), ), CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_LAST, EditorContextKeys.isEmbeddedDiffEditor.negate() ), primary: KeyCode.DownArrow, weight: KeybindingWeight.EditorCore }, { when: ContextKeyExpr.and( NOTEBOOK_EDITOR_FOCUSED, CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate(), ContextKeyExpr.equals('config.notebook.navigation.allowNavigateToSurroundingCells', true), ContextKeyExpr.and( NOTEBOOK_CELL_TYPE.isEqualTo('markup'), NOTEBOOK_CELL_MARKDOWN_EDIT_MODE.isEqualTo(false), NOTEBOOK_CURSOR_NAVIGATION_MODE), CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_LAST, EditorContextKeys.isEmbeddedDiffEditor.negate() ), primary: KeyCode.DownArrow, weight: KeybindingWeight.EditorCore }, { </del> when: NOTEBOOK_EDITOR_FOCUSED, primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.PageDown, mac: { primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.PageDown, },


super({ id: NOTEBOOK_FOCUS_PREVIOUS_EDITOR, title: localize('cursorMoveUp', 'Focus Previous Cell Editor'), <del> precondition: CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate(), </del> keybinding: [ { when: ContextKeyExpr.and(


id: AccessibilityCommandId.AccessibleViewAcceptInlineCompletion, precondition: ContextKeyExpr.and(accessibleViewIsShown, ContextKeyExpr.equals(accessibleViewCurrentProviderId.key, AccessibleViewProviderId.InlineCompletions)), keybinding: { <del> primary: KeyMod.CtrlCmd | KeyCode.Enter, mac: { primary: KeyMod.WinCtrl | KeyCode.Enter }, </del> <ins> primary: KeyMod.CtrlCmd | KeyCode.Slash, mac: { primary: KeyMod.WinCtrl | KeyCode.Slash }, </ins> weight: KeybindingWeight.WorkbenchContrib }, icon: Codicon.check,


return undefined; } <ins> export async function getDocumentFormattingEditsWithSelectedProvider( workerService: IEditorWorkerService, languageFeaturesService: ILanguageFeaturesService, editorOrModel: ITextModel | IActiveCodeEditor, mode: FormattingMode, token: CancellationToken, ): Promise<TextEdit[] | undefined> { const model = isCodeEditor(editorOrModel) ? editorOrModel.getModel() : editorOrModel; const provider = getRealAndSyntheticDocumentFormattersOrdered(languageFeaturesService.documentFormattingEditProvider, languageFeaturesService.documentRangeFormattingEditProvider, model); const selected = await FormattingConflicts.select(provider, model, mode, FormattingKind.File); if (selected) { const rawEdits = await Promise.resolve(selected.provideDocumentFormattingEdits(model, model.getOptions(), token)).catch(onUnexpectedExternalError); return await workerService.computeMoreMinimalEdits(model.uri, rawEdits); } return undefined; } </ins> export function getOnTypeFormattingEdits( workerService: IEditorWorkerService, languageFeaturesService: ILanguageFeaturesService,


import { IEditorWorkerService } from 'vs/editor/common/services/editorWorker'; import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures'; import { ITextModelService } from 'vs/editor/common/services/resolverService'; <del> import { FormattingMode, formatDocumentWithSelectedProvider, getDocumentFormattingEditsUntilResult } from 'vs/editor/contrib/format/browser/format'; </del> <ins> import { FormattingMode, formatDocumentWithSelectedProvider, getDocumentFormattingEditsWithSelectedProvider } from 'vs/editor/contrib/format/browser/format'; </ins> import { Action2, MenuId, registerAction2 } from 'vs/platform/actions/common/actions'; import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey'; import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';


const model = ref.object.textEditorModel; <del> const formatEdits = await getDocumentFormattingEditsUntilResult( </del> <ins> const formatEdits = await getDocumentFormattingEditsWithSelectedProvider( </ins> editorWorkerService, languageFeaturesService, model, <del> model.getOptions(), </del> <ins> FormattingMode.Explicit, </ins> CancellationToken.None );


const model = ref.object.textEditorModel; <del> // todo: eventually support cancellation. potential leak if cell deleted mid execution const formatEdits = await getDocumentFormattingEditsUntilResult( </del> <ins> const formatEdits = await getDocumentFormattingEditsWithSelectedProvider( </ins> this.editorWorkerService, this.languageFeaturesService, model, <del> model.getOptions(), </del> <ins> FormattingMode.Silent, </ins> CancellationToken.None );


import { ITextModelService } from 'vs/editor/common/services/resolverService'; import { ApplyCodeActionReason, applyCodeAction, getCodeActions } from 'vs/editor/contrib/codeAction/browser/codeAction'; import { CodeActionKind, CodeActionTriggerSource } from 'vs/editor/contrib/codeAction/common/types'; <del> import { getDocumentFormattingEditsUntilResult } from 'vs/editor/contrib/format/browser/format'; </del> <ins> import { FormattingMode, getDocumentFormattingEditsWithSelectedProvider } from 'vs/editor/contrib/format/browser/format'; </ins> import { SnippetController2 } from 'vs/editor/contrib/snippet/browser/snippetController2'; import { localize } from 'vs/nls'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration';


const model = ref.object.textEditorModel; <del> const formatEdits = await getDocumentFormattingEditsUntilResult( </del> <ins> const formatEdits = await getDocumentFormattingEditsWithSelectedProvider( </ins> this.editorWorkerService, this.languageFeaturesService, model, <del> model.getOptions(), </del> <ins> FormattingMode.Silent, </ins> token );


const activeTextEditor = window.activeTextEditor; // Must extract these now because opening a new document will change the activeTextEditor reference <del> const previousVisibleRange = activeTextEditor?.visibleRanges[0]; </del> <ins> const previousVisibleRanges = activeTextEditor?.visibleRanges; </ins> const previousURI = activeTextEditor?.document.uri; const previousSelection = activeTextEditor?.selection;


opts.selection = previousSelection; const editor = await window.showTextDocument(document, opts); // This should always be defined but just in case <del> if (previousVisibleRange) { editor.revealRange(previousVisibleRange); </del> <ins> if (previousVisibleRanges && previousVisibleRanges.length > 0) { let rangeToReveal = previousVisibleRanges[0]; if (previousSelection && previousVisibleRanges.length > 1) { // In case of multiple visible ranges, find the one that intersects with the selection rangeToReveal = previousVisibleRanges.find(r => r.intersection(previousSelection)) ?? rangeToReveal; } editor.revealRange(rangeToReveal); </ins> } } }


<meta charset="UTF-8"> <meta http-equiv="Content-Security-Policy" <del> content="default-src 'none'; script-src 'sha256-QA1gXilHYAUFCvp7MpjgcmyBCFzSKV0SpiecMU8aUVc=' 'self'; frame-src 'self'; style-src 'unsafe-inline';"> </del> <ins> content="default-src 'none'; script-src 'sha256-Ne5nVg2ZDLxLh1eqzYd1sGbOz022xlokwv+X6+HR1hw=' 'self'; frame-src 'self'; style-src 'unsafe-inline';"> </ins> <!-- Disable pinch zooming --> <meta name="viewport"


} code { <ins> font-family: var(--monaco-monospace-font); </ins> color: var(--vscode-textPreformat-foreground); <ins> font-size: 12px; background-color: var(--vscode-textPreformat-background); padding: 1px 3px; border-radius: 4px; </ins> } blockquote {


) { } showHover(options: IHoverDelegateOptions, focus?: boolean): IHoverWidget | undefined { <ins> // Only show the hover hint if the content is of a decent size const showHoverHint = ( options.content instanceof HTMLElement ? options.content.textContent ?? '' : typeof options.content === 'string' ? options.content : options.content.value ).length > 20; </ins> return this.hoverService.showHover({ ...options, persistence: { hideOnKeyDown: false, }, appearance: { <del> showHoverHint: true, </del> <ins> showHoverHint, </ins> skipFadeInAnimation: true, }, }, focus);


*/ mode?: 'prefix' | 'subword' | 'subwordSmart'; <del> showToolbar?: 'always' | 'onHover'; </del> <ins> showToolbar?: 'always' | 'onHover' | 'never'; </ins> suppressSuggestions?: boolean;


'editor.inlineSuggest.showToolbar': { type: 'string', default: defaults.showToolbar, <del> enum: ['always', 'onHover'], </del> <ins> enum: ['always', 'onHover', 'never'], </ins> enumDescriptions: [ nls.localize('inlineSuggest.showToolbar.always', "Show the inline suggestion toolbar whenever an inline suggestion is shown."), nls.localize('inlineSuggest.showToolbar.onHover', "Show the inline suggestion toolbar when hovering over an inline suggestion."), <ins> nls.localize('inlineSuggest.showToolbar.never', "Never show the inline suggestion toolbar."), </ins> ], description: nls.localize('inlineSuggest.showToolbar', "Controls when to show the inline suggestion toolbar."), },


return { enabled: boolean(input.enabled, this.defaultValue.enabled), mode: stringSet(input.mode, this.defaultValue.mode, ['prefix', 'subword', 'subwordSmart']), <del> showToolbar: stringSet(input.showToolbar, this.defaultValue.showToolbar, ['always', 'onHover']), </del> <ins> showToolbar: stringSet(input.showToolbar, this.defaultValue.showToolbar, ['always', 'onHover', 'never']), </ins> suppressSuggestions: boolean(input.suppressSuggestions, this.defaultValue.suppressSuggestions), keepOnBlur: boolean(input.keepOnBlur, this.defaultValue.keepOnBlur), };


} computeSync(anchor: HoverAnchor, lineDecorations: IModelDecoration[]): InlineCompletionsHover[] { <del> if (this._editor.getOption(EditorOption.inlineSuggest).showToolbar === 'always') { </del> <ins> if (this._editor.getOption(EditorOption.inlineSuggest).showToolbar !== 'onHover') { </ins> return []; }


* Defaults to `prefix`. */ mode?: 'prefix' | 'subword' | 'subwordSmart'; <del> showToolbar?: 'always' | 'onHover'; </del> <ins> showToolbar?: 'always' | 'onHover' | 'never'; </ins> suppressSuggestions?: boolean; /** * Does not clear active inline suggestions when the editor loses focus.


".eyaml", ".eyml", ".yaml", <del> ".cff" </del> <ins> ".cff", ".yaml-tmlanguage", ".yaml-tmpreferences", ".yaml-tmtheme" </ins> ], "firstLine": "^#cloud-config", "configuration": "./language-configuration.json"


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


const lastUnchangedRegions = this._unchangedRegions.get(); const lastUnchangedRegionsOrigRanges = lastUnchangedRegions.originalDecorationIds .map(id => model.original.getDecorationRange(id)) <del> .filter(r => !!r) .map(r => LineRange.fromRange(r!)); </del> <ins> .map(r => r ? LineRange.fromRange(r) : undefined); </ins> const lastUnchangedRegionsModRanges = lastUnchangedRegions.modifiedDecorationIds .map(id => model.modified.getDecorationRange(id)) <del> .filter(r => !!r) .map(r => LineRange.fromRange(r!)); </del> <ins> .map(r => r ? LineRange.fromRange(r) : undefined); </ins> const originalDecorationIds = model.original.deltaDecorations( lastUnchangedRegions.originalDecorationIds,


for (const r of newUnchangedRegions) { for (let i = 0; i < lastUnchangedRegions.regions.length; i++) { <del> if (r.originalUnchangedRange.intersectsStrict(lastUnchangedRegionsOrigRanges[i]) && r.modifiedUnchangedRange.intersectsStrict(lastUnchangedRegionsModRanges[i])) { </del> <ins> if (lastUnchangedRegionsOrigRanges[i] && r.originalUnchangedRange.intersectsStrict(lastUnchangedRegionsOrigRanges[i]!) && lastUnchangedRegionsModRanges[i] && r.modifiedUnchangedRange.intersectsStrict(lastUnchangedRegionsModRanges[i]!)) { </ins> r.setHiddenModifiedRange(lastUnchangedRegions.regions[i].getHiddenModifiedRange(undefined), tx); break; }


import { MarkdownString } from 'vs/base/common/htmlContent'; import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; import { LOCALIZED_START_INLINE_CHAT_STRING } from 'vs/workbench/contrib/inlineChat/browser/inlineChatActions'; <del> import { IBreakpoint, IDebugService } from 'vs/workbench/contrib/debug/common/debug'; </del> <ins> import { IBreakpoint, IDebugService, IDebugSession } from 'vs/workbench/contrib/debug/common/debug'; </ins> import { IPreferencesService } from 'vs/workbench/services/preferences/common/preferences'; import { URI } from 'vs/base/common/uri';


private _gutterDecorationID: string | undefined; private _inlineChatKeybinding: string | undefined; private _hasInlineChatSession: boolean = false; <ins> private _hasActiveDebugSession: boolean = false; private _debugSessions: Set<IDebugSession> = new Set(); </ins> private readonly _localToDispose = new DisposableStore(); private readonly _gutterDecorationOpaque: IModelDecorationOptions; private readonly _gutterDecorationTransparent: IModelDecorationOptions;


this._onEnablementOrModelChanged(); } })); <ins> this._register(this._debugService.onWillNewSession((session) => { this._debugSessions.add(session); if (!this._hasActiveDebugSession) { this._hasActiveDebugSession = true; this._onEnablementOrModelChanged(); } })); this._register(this._debugService.onDidEndSession((session) => { this._debugSessions.delete(session); if (this._debugSessions.size === 0) { this._hasActiveDebugSession = false; this._onEnablementOrModelChanged(); } })); </ins> this._register(this._inlineChatService.onDidChangeProviders(() => this._onEnablementOrModelChanged())); this._register(this._editor.onDidChangeModel(() => this._onEnablementOrModelChanged())); this._register(this._keybindingService.onDidUpdateKeybindings(() => {


private _onEnablementOrModelChanged(): void { // cancels the scheduler, removes editor listeners / removes decoration this._localToDispose.clear(); <del> if (!this._editor.hasModel() || this._hasInlineChatSession || this._showGutterIconMode() === ShowGutterIcon.Never || !this._hasProvider()) { </del> <ins> if (!this._editor.hasModel() || this._hasActiveDebugSession || this._hasInlineChatSession || this._showGutterIconMode() === ShowGutterIcon.Never || !this._hasProvider()) { </ins> return; } const editor = this._editor;


*--------------------------------------------------------------------------------------------*/ import { LazyStatefulPromise, raceTimeout } from 'vs/base/common/async'; <ins> import { onUnexpectedError } from 'vs/base/common/errors'; </ins> import { IDisposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle'; import { deepClone } from 'vs/base/common/objects'; <del> import { isObject } from 'vs/base/common/types'; </del> <ins> import { isDefined, isObject } from 'vs/base/common/types'; </ins> import { URI } from 'vs/base/common/uri'; import { ConstLazyPromise, IDocumentDiffItem, IMultiDiffEditorModel } from 'vs/editor/browser/widget/multiDiffEditorWidget/model'; import { MultiDiffEditorViewModel } from 'vs/editor/browser/widget/multiDiffEditorWidget/multiDiffEditorViewModel';


import { EditorInput } from 'vs/workbench/common/editor/editorInput'; import { ILanguageSupport } from 'vs/workbench/services/textfile/common/textfiles'; <ins> /* hot-reload:patch-prototype-methods */ </ins> export class MultiDiffEditorInput extends EditorInput implements ILanguageSupport { static readonly ID: string = 'workbench.input.multiDiffEditor';


private async _createModel(): Promise<IMultiDiffEditorModel & IDisposable> { const store = new DisposableStore(); <del> const rs = await Promise.all(this.resources.map(async r => ({ originalRef: r.original ? store.add(await this._textModelService.createModelReference(r.original)) : undefined, originalModel: !r.original ? store.add(this._modelService.createModel('', null)) : undefined, modifiedRef: r.modified ? store.add(await this._textModelService.createModelReference(r.modified)) : undefined, modifiedModel: !r.modified ? store.add(this._modelService.createModel('', null)) : undefined, title: r.resource.fsPath, }))); </del> <ins> const rs = (await Promise.all(this.resources.map(async r => { try { return { originalRef: r.original ? store.add(await this._textModelService.createModelReference(r.original)) : undefined, originalModel: !r.original ? store.add(this._modelService.createModel('', null)) : undefined, modifiedRef: r.modified ? store.add(await this._textModelService.createModelReference(r.modified)) : undefined, modifiedModel: !r.modified ? store.add(this._modelService.createModel('', null)) : undefined, title: r.resource.fsPath, }; } catch (e) { // e.g. "File seems to be binary and cannot be opened as text" console.error(e); onUnexpectedError(e); return undefined; } }))).filter(isDefined); </ins> const textResourceConfigurationService = this._textResourceConfigurationService;


this.logService.trace(`Extension signature verification details for ${extension.identifier.id} ${extension.version}:n${sigError.output}`); } if (verificationStatus === ExtensionSignaturetErrorCode.PackageIsInvalidZip || verificationStatus === ExtensionSignaturetErrorCode.SignatureArchiveIsInvalidZip) { <ins> try { // Delete the downloaded vsix before throwing the error await this.delete(location); } catch (error) { this.logService.error(error); } </ins> throw new ExtensionManagementError(CorruptZipMessage, ExtensionManagementErrorCode.CorruptZip); } } finally {


public static INSTANCE = new EditorRenderingCoordinator(); private _coordinatedRenderings: ICoordinatedRendering[] = []; <del> private _animationFrameRunner: IDisposable | null = null; </del> <ins> private _animationFrameRunners = new Map<CodeWindow, IDisposable>(); </ins> private constructor() { }


this._coordinatedRenderings.splice(renderingIndex, 1); if (this._coordinatedRenderings.length === 0) { <del> // There are no more renderings to coordinate => cancel animation frame if (this._animationFrameRunner !== null) { this._animationFrameRunner.dispose(); this._animationFrameRunner = null; </del> <ins> // There are no more renderings to coordinate => cancel animation frames for (const [_, disposable] of this._animationFrameRunners) { disposable.dispose(); </ins> } <ins> this._animationFrameRunners.clear(); </ins> } } }; } private _scheduleRender(window: CodeWindow): void { <del> if (this._animationFrameRunner === null) { </del> <ins> if (!this._animationFrameRunners.has(window)) { </ins> const runner = () => { <del> this._animationFrameRunner = null; </del> <ins> this._animationFrameRunners.delete(window); </ins> this._onRenderScheduled(); }; <del> this._animationFrameRunner = dom.runAtThisOrScheduleAtNextAnimationFrame(window, runner, 100); </del> <ins> this._animationFrameRunners.set(window, dom.runAtThisOrScheduleAtNextAnimationFrame(window, runner, 100)); </ins> } }


const ignoreImportantExtensionRecommendationStorageKey = 'extensionsAssistant/importantRecommendationsIgnore'; const donotShowWorkspaceRecommendationsStorageKey = 'extensionsAssistant/workspaceRecommendationsIgnore'; <del> const choiceNever = localize('neverShowAgain', "Don't Show Again"); </del> type RecommendationsNotificationActions = { onDidInstallRecommendedExtensions(extensions: IExtension[]): void;


searchValue = source === RecommendationSource.WORKSPACE ? '@recommended' : extensions.map(extensionId => `@id:${extensionId.identifier.id}`).join(' '); } <ins> const donotShowAgainLabel = source === RecommendationSource.WORKSPACE ? localize('donotShowAgain', "Don't Show Again for this Repository") : extensions.length > 1 ? localize('donotShowAgainExtension', "Don't Show Again for these Extensions") : localize('donotShowAgainExtensionSingle', "Don't Show Again for this Extension"); </ins> return raceCancellablePromises([ <del> this._registerP(this.showRecommendationsNotification(extensions, message, searchValue, source, recommendationsNotificationActions)), </del> <ins> this._registerP(this.showRecommendationsNotification(extensions, message, searchValue, donotShowAgainLabel, source, recommendationsNotificationActions)), </ins> this._registerP(this.waitUntilRecommendationsAreInstalled(extensions)) ]); } <del> private showRecommendationsNotification(extensions: IExtension[], message: string, searchValue: string, source: RecommendationSource, </del> <ins> private showRecommendationsNotification(extensions: IExtension[], message: string, searchValue: string, donotShowAgainLabel: string, source: RecommendationSource, </ins> { onDidInstallRecommendedExtensions, onDidShowRecommendedExtensions, onDidCancelRecommendedExtensions, onDidNeverShowRecommendedExtensionsAgain }: RecommendationsNotificationActions): CancelablePromise<RecommendationsNotificationResult> { return createCancelablePromise<RecommendationsNotificationResult>(async token => { let accepted = false;


this.runAction(this.instantiationService.createInstance(SearchExtensionsAction, searchValue)); } }, { <del> label: choiceNever, </del> <ins> label: donotShowAgainLabel, </ins> isSecondary: true, run: () => { onDidNeverShowRecommendedExtensionsAgain(extensions);


applyStatusBarStyle(); applyIconStyle(); } <ins> if (this._completionModel && (e.hasChanged(EditorOption.fontInfo) || e.hasChanged(EditorOption.suggestFontSize) || e.hasChanged(EditorOption.suggestLineHeight))) { this._list.splice(0, this._list.length, this._completionModel.items); } </ins> })); this._ctxSuggestWidgetVisible = SuggestContext.Visible.bindTo(_contextKeyService);


readonly detailsLabel: HTMLElement; readonly readMore: HTMLElement; readonly disposables: DisposableStore; <ins> readonly configureFont: () => void; </ins> } export class ItemRenderer implements IListRenderer<CompletionItem, ISuggestionTemplateData> {


readMore.style.width = lineHeightPx; }; <del> configureFont(); disposables.add(this._editor.onDidChangeConfiguration(e => { if (e.hasChanged(EditorOption.fontInfo) || e.hasChanged(EditorOption.suggestFontSize) || e.hasChanged(EditorOption.suggestLineHeight)) { configureFont(); } })); return { root, left, right, icon, colorspan, iconLabel, iconContainer, parametersLabel, qualifierLabel, detailsLabel, readMore, disposables }; </del> <ins> return { root, left, right, icon, colorspan, iconLabel, iconContainer, parametersLabel, qualifierLabel, detailsLabel, readMore, disposables, configureFont }; </ins> } renderElement(element: CompletionItem, index: number, data: ISuggestionTemplateData): void { <ins> data.configureFont(); </ins> const { completion } = element; data.root.id = getAriaId(index); data.colorspan.style.backgroundColor = '';


}; // Update group contexts based on group changes <del> this._register(this.onDidModelChange(e => { </del> <ins> const updateGroupContextKeys = (e: IGroupModelChangeEvent) => { </ins> switch (e.kind) { case GroupModelChangeKind.GROUP_LOCKED: groupLockedContext.set(this.isLocked);


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


localize('voice.keywordActivation.inlineChat', "Keyword activation is enabled and listening for 'Hey Code' to start a voice chat session in the active editor."), localize('voice.keywordActivation.chatInContext', "Keyword activation is enabled and listening for 'Hey Code' to start a voice chat session in the active editor or view depending on keyboard focus.") ], <del> 'description': localize('voice.keywordActivation', "Controls whether the phrase 'Hey Code' should be speech recognized to start a voice chat session."), </del> <ins> 'description': localize('voice.keywordActivation', "Controls whether the keyword phrase 'Hey Code' is recognized to start a voice chat session. Enabling this will start recording from the microphone but the audio is processed locally and never sent to a server."), </ins> 'default': 'off', 'tags': ['accessibility', 'FeatureInsight'] }


"input.background": "#313131", "input.border": "#3C3C3C", "input.foreground": "#CCCCCC", <del> "input.placeholderForeground": "#818181", </del> <ins> "input.placeholderForeground": "#989898", </ins> "inputOption.activeBackground": "#2489DB82", "inputOption.activeBorder": "#2488DB", "keybindingLabel.foreground": "#CCCCCC",


"input.background": "#FFFFFF", "input.border": "#CECECE", "input.foreground": "#3B3B3B", <del> "input.placeholderForeground": "#868686", </del> <ins> "input.placeholderForeground": "#767676", </ins> "inputOption.activeBackground": "#BED6ED", "inputOption.activeBorder": "#005FB8", "inputOption.activeForeground": "#000000",


return -1; } <ins> if (result !== 0) { return result; } </ins> if (a.multiFileDiffEditorModifiedUri && b.multiFileDiffEditorModifiedUri) { result = comparePaths(a.multiFileDiffEditorModifiedUri.fsPath, b.multiFileDiffEditorModifiedUri.fsPath, true); } else if (a.multiFileDiffEditorModifiedUri) {


} else if (b.multiFileDiffEditorModifiedUri) { return -1; } <ins> if (result !== 0) { return result; } </ins> if (a.multiDiffEditorOriginalUri && b.multiDiffEditorOriginalUri) { result = comparePaths(a.multiDiffEditorOriginalUri.fsPath, b.multiDiffEditorOriginalUri.fsPath, true); } else if (a.multiDiffEditorOriginalUri) {


protected override renderBody(container: HTMLElement): void { super.renderBody(container); <ins> this.element.classList.add('debug-pane'); </ins> this.tree = <WorkbenchAsyncDataTree<INotebookScope, INotebookVariableElement>>this.instantiationService.createInstance( WorkbenchAsyncDataTree,


private renderMarkerStatusbar(context: IEditorHoverRenderContext, markerHover: MarkerHover, disposables: DisposableStore): void { if (markerHover.marker.severity === MarkerSeverity.Error || markerHover.marker.severity === MarkerSeverity.Warning || markerHover.marker.severity === MarkerSeverity.Info) { <del> context.statusBar.addAction({ label: nls.localize('view problem', "View Problem"), commandId: NextMarkerAction.ID, run: () => { context.hide(); MarkerController.get(this._editor)?.showAtMarker(markerHover.marker); this._editor.focus(); } }); </del> <ins> const markerController = MarkerController.get(this._editor); if (markerController) { context.statusBar.addAction({ label: nls.localize('view problem', "View Problem"), commandId: NextMarkerAction.ID, run: () => { context.hide(); markerController.showAtMarker(markerHover.marker); this._editor.focus(); } }); } </ins> } if (!this._editor.getOption(EditorOption.readOnly)) {


import { getWindow, runWhenWindowIdle } from 'vs/base/browser/dom'; import { onUnexpectedError } from 'vs/base/common/errors'; <del> import { Disposable, DisposableMap } from 'vs/base/common/lifecycle'; </del> <ins> import { Disposable, DisposableMap, IDisposable } from 'vs/base/common/lifecycle'; </ins> import { ICodeEditor } from 'vs/editor/browser/editorBrowser'; import { EditorContributionInstantiation, IEditorContributionDescription } from 'vs/editor/browser/editorExtensions'; import { IEditorContribution } from 'vs/editor/common/editorCommon';


this._instantiateSome(EditorContributionInstantiation.BeforeFirstInteraction); } <del> public onAfterModelAttached(): void { this._register(runWhenWindowIdle(getWindow(this._editor?.getDomNode()), () => { </del> <ins> public onAfterModelAttached(): IDisposable { return runWhenWindowIdle(getWindow(this._editor?.getDomNode()), () => { </ins> this._instantiateSome(EditorContributionInstantiation.AfterFirstRender); <del> }, 50)); </del> <ins> }, 50); </ins> } private _instantiateSome(instantiation: EditorContributionInstantiation): void {


private readonly _overflowWidgetsDomNode: HTMLElement | undefined; private readonly _id: number; private readonly _configuration: IEditorConfiguration; <ins> private _contributionsDisposable: IDisposable | undefined; </ins> protected readonly _actions = new Map<string, editorCommon.IEditorAction>();


this._onDidChangeModel.fire(e); this._postDetachModelCleanup(detachedModel); <del> this._contributions.onAfterModelAttached(); </del> <ins> this._contributionsDisposable = this._contributions.onAfterModelAttached(); </ins> } private _removeDecorationTypes(): void {


} private _detachModel(): ITextModel | null { <ins> this._contributionsDisposable?.dispose(); this._contributionsDisposable = undefined; </ins> if (!this._modelData) { return null; }


if (this._bannerDomNode && this._domElement.contains(this._bannerDomNode)) { this._domElement.removeChild(this._bannerDomNode); } return model; }


position: relative; padding: 0 6px; margin-bottom: 4px; <del> align-items: center; </del> <ins> align-items: flex-end; </ins> justify-content: space-between; }


.interactive-session .interactive-input-part .interactive-execute-toolbar { height: 22px; <ins> /* It's bottom-aligned, make it appear centered within the container */ margin-bottom: 7px; </ins> } .interactive-session .interactive-input-part .interactive-execute-toolbar .codicon-debug-stop {


} .quick-input-widget .interactive-session .interactive-input-part .interactive-execute-toolbar { <del> bottom: 1px; </del> <ins> margin-bottom: 1px; </ins> } .quick-input-widget .interactive-session .interactive-input-and-execute-toolbar {


private _sessionCtor: CancelablePromise<void> | undefined; private _activeSession?: Session; private _warmupRequestCts?: CancellationTokenSource; <ins> private _activeRequestCts?: CancellationTokenSource; </ins> private readonly _ctxHasActiveRequest: IContextKey<boolean>; private readonly _ctxCellWidgetFocused: IContextKey<boolean>; private readonly _ctxUserDidEdit: IContextKey<boolean>;


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


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


} }); <del> const task = this._activeSession.provider.provideResponse(this._activeSession.session, request, progress, requestCts.token); </del> <ins> const task = this._activeSession.provider.provideResponse(this._activeSession.session, request, progress, this._activeRequestCts.token); </ins> let response: ReplyResponse | ErrorResponse | EmptyResponse; try {


this._widget?.inlineChatWidget.updateInfo(!this._activeSession.lastExchange ? localize('thinking', "Thinkingu2026") : ''); this._ctxHasActiveRequest.set(true); <del> const reply = await raceCancellationError(Promise.resolve(task), requestCts.token); </del> <ins> const reply = await raceCancellationError(Promise.resolve(task), this._activeRequestCts.token); </ins> if (progressiveEditsQueue.size > 0) { // we must wait for all edits that came in via progress to complete await Event.toPromise(progressiveEditsQueue.onDrained);


this._widget?.inlineChatWidget.updateInfo(''); this._widget?.inlineChatWidget.updateToolbar(true); <del> this._activeSession.addExchange(new SessionExchange(this._activeSession.lastInput, response)); </del> <ins> this._activeSession?.addExchange(new SessionExchange(this._activeSession.lastInput, response)); </ins> this._ctxLastResponseType.set(response instanceof ReplyResponse ? response.raw.type : undefined); }


this._strategy?.cancel(); } <del> if (this._activeSession) { this._inlineChatSessionService.releaseSession(this._activeSession); } this._activeSession = undefined; </del> <ins> this._activeRequestCts?.cancel(); </ins> } discard() { this._strategy?.cancel(); <ins> this._activeRequestCts?.cancel(); </ins> this._widget?.discardChange(); this.dismiss(); }


const titleElement = container.querySelector('.title') as HTMLElement; const setHeader = () => { <del> const workspace = this.contextService.getWorkspace(); const title = workspace.folders.map(folder => folder.name).join(); </del> titleElement.textContent = this.name; <del> this.updateTitle(title); </del> <ins> this.updateTitle(this.name); </ins> this.ariaHeaderLabel = nls.localize('explorerSection', "Explorer Section: {0}", this.name); titleElement.setAttribute('aria-label', this.ariaHeaderLabel); };


.monaco-workbench .interactive-input-part .monaco-action-bar .action-label.codicon-loading.codicon-modifier-spin:not(.disabled)::before, .monaco-workbench .inline-chat .monaco-action-bar .action-label.codicon-loading.codicon-modifier-spin:not(.disabled)::before { content: "ec1c"; <ins> font-family: 'codicon'; </ins> } /*


.monaco-workbench.reduce-motion .interactive-input-part .monaco-action-bar .action-label.codicon-loading.codicon-modifier-spin:not(.disabled)::before, .monaco-workbench.reduce-motion .inline-chat .monaco-action-bar .action-label.codicon-loading.codicon-modifier-spin:not(.disabled)::before { content: "ead7"; <ins> font-family: 'codicon'; </ins> }


.quick-input-list .quick-input-list-entry.has-actions:hover .quick-input-list-entry-action-bar .action-label.dirty-anything::before { content: "ea76"; /* Close icon flips between black dot and "X" for dirty open editors */ <ins> font-family: 'codicon'; </ins> }


}; private readonly closeDirtyWindowAction: IQuickInputButton = { <del> iconClass: 'dirty-window ' + Codicon.closeDirty, </del> <ins> iconClass: 'dirty-window ' + ThemeIcon.asClassName(Codicon.closeDirty), </ins> tooltip: localize('close', "Close Window"), alwaysVisible: true };


*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> import { DisposableStore } from 'vs/base/common/lifecycle'; import { ExtHostContext, IExtHostEditorTabsShape, MainContext, IEditorTabDto, IEditorTabGroupDto, MainThreadEditorTabsShape, AnyInputDto, TabInputKind, TabModelOperationKind, TextDiffInputDto } from 'vs/workbench/api/common/extHost.protocol'; import { extHostNamedCustomer, IExtHostContext } from 'vs/workbench/services/extensions/common/extHostCustomers'; </del> <ins> import { Event } from 'vs/base/common/event'; import { DisposableMap, DisposableStore } from 'vs/base/common/lifecycle'; import { isEqual } from 'vs/base/common/resources'; import { URI } from 'vs/base/common/uri'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { ILogService } from 'vs/platform/log/common/log'; import { AnyInputDto, ExtHostContext, IEditorTabDto, IEditorTabGroupDto, IExtHostEditorTabsShape, MainContext, MainThreadEditorTabsShape, TabInputKind, TabModelOperationKind, TextDiffInputDto } from 'vs/workbench/api/common/extHost.protocol'; </ins> import { EditorResourceAccessor, GroupModelChangeKind, SideBySideEditor } from 'vs/workbench/common/editor'; import { DiffEditorInput } from 'vs/workbench/common/editor/diffEditorInput'; <ins> import { isGroupEditorMoveEvent } from 'vs/workbench/common/editor/editorGroupModel'; </ins> import { EditorInput } from 'vs/workbench/common/editor/editorInput'; <del> import { columnToEditorGroup, EditorGroupColumn, editorGroupToColumn } from 'vs/workbench/services/editor/common/editorGroupColumn'; import { GroupDirection, IEditorGroup, IEditorGroupsService, preferredSideBySideGroupDirection } from 'vs/workbench/services/editor/common/editorGroupsService'; import { IEditorsChangeEvent, IEditorService, SIDE_GROUP } from 'vs/workbench/services/editor/common/editorService'; </del> <ins> import { SideBySideEditorInput } from 'vs/workbench/common/editor/sideBySideEditorInput'; </ins> import { AbstractTextResourceEditorInput } from 'vs/workbench/common/editor/textResourceEditorInput'; <del> import { NotebookEditorInput } from 'vs/workbench/contrib/notebook/common/notebookEditorInput'; </del> <ins> import { ChatEditorInput } from 'vs/workbench/contrib/chat/browser/chatEditorInput'; </ins> import { CustomEditorInput } from 'vs/workbench/contrib/customEditor/browser/customEditorInput'; <del> import { URI } from 'vs/base/common/uri'; import { WebviewInput } from 'vs/workbench/contrib/webviewPanel/browser/webviewEditorInput'; import { TerminalEditorInput } from 'vs/workbench/contrib/terminal/browser/terminalEditorInput'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { SideBySideEditorInput } from 'vs/workbench/common/editor/sideBySideEditorInput'; import { isEqual } from 'vs/base/common/resources'; import { isGroupEditorMoveEvent } from 'vs/workbench/common/editor/editorGroupModel'; </del> import { InteractiveEditorInput } from 'vs/workbench/contrib/interactive/browser/interactiveEditorInput'; import { MergeEditorInput } from 'vs/workbench/contrib/mergeEditor/browser/mergeEditorInput'; <del> import { ILogService } from 'vs/platform/log/common/log'; import { ChatEditorInput } from 'vs/workbench/contrib/chat/browser/chatEditorInput'; </del> import { MultiDiffEditorInput } from 'vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput'; <ins> import { NotebookEditorInput } from 'vs/workbench/contrib/notebook/common/notebookEditorInput'; import { TerminalEditorInput } from 'vs/workbench/contrib/terminal/browser/terminalEditorInput'; import { WebviewInput } from 'vs/workbench/contrib/webviewPanel/browser/webviewEditorInput'; import { columnToEditorGroup, EditorGroupColumn, editorGroupToColumn } from 'vs/workbench/services/editor/common/editorGroupColumn'; import { GroupDirection, IEditorGroup, IEditorGroupsService, preferredSideBySideGroupDirection } from 'vs/workbench/services/editor/common/editorGroupsService'; import { IEditorsChangeEvent, IEditorService, SIDE_GROUP } from 'vs/workbench/services/editor/common/editorService'; import { extHostNamedCustomer, IExtHostContext } from 'vs/workbench/services/extensions/common/extHostCustomers'; </ins> interface TabInfo { tab: IEditorTabDto;


private readonly _groupLookup: Map<number, IEditorTabGroupDto> = new Map(); // Lookup table for finding tab by id private readonly _tabInfoLookup: Map<string, TabInfo> = new Map(); <ins> // Tracks the currently open MultiDiffEditorInputs to listen to resource changes private readonly _multiDiffEditorInputListeners: DisposableMap<MultiDiffEditorInput> = new DisposableMap(); </ins> constructor( extHostContext: IExtHostContext,


} })); <ins> this._dispoables.add(this._multiDiffEditorInputListeners); </ins> // Structural group changes (add, remove, move, etc) are difficult to patch. // Since they happen infrequently we just rebuild the entire model this._dispoables.add(this._editorGroupsService.onDidAddGroup(() => this._createTabsModel()));


if (editor instanceof MultiDiffEditorInput) { const diffEditors: TextDiffInputDto[] = []; <del> for (const resource of (editor?.initialResources ?? [])) { </del> <ins> for (const resource of (editor?.resources.get() ?? [])) { </ins> if (resource.original && resource.modified) { diffEditors.push({ kind: TabInputKind.TextDiffInput,


const tabObject = this._buildTabObject(group, editorInput, editorIndex); tabs.splice(editorIndex, 0, tabObject); // Update lookup <del> this._tabInfoLookup.set(this._generateTabId(editorInput, groupId), { group, editorInput, tab: tabObject }); </del> <ins> const tabId = this._generateTabId(editorInput, groupId); this._tabInfoLookup.set(tabId, { group, editorInput, tab: tabObject }); if (editorInput instanceof MultiDiffEditorInput) { this._multiDiffEditorInputListeners.set(editorInput, Event.fromObservableLight(editorInput.resources)(() => { const tabInfo = this._tabInfoLookup.get(tabId); if (!tabInfo) { return; } tabInfo.tab = this._buildTabObject(group, editorInput, editorIndex); this._proxy.$acceptTabOperation({ groupId, index: editorIndex, tabDto: tabInfo.tab, kind: TabModelOperationKind.TAB_UPDATE }); })); } </ins> this._proxy.$acceptTabOperation({ groupId,


// Update lookup this._tabInfoLookup.delete(removedTab[0]?.id ?? ''); <ins> if (removedTab[0]?.input instanceof MultiDiffEditorInput) { this._multiDiffEditorInputListeners.deleteAndDispose(removedTab[0]?.input); } </ins> this._proxy.$acceptTabOperation({ groupId, index: editorIndex,


this._register(autorun((reader) => { /** @description Updates name */ <del> const resources = this._resources.read(reader); </del> <ins> const resources = this.resources.read(reader); </ins> const label = this.label ?? localize('name', "Multi Diff Editor"); if (resources) { this._name = label + localize({


return false; } <del> private readonly _resources = derived(this, reader => this._resolvedSource.cachedPromiseResult.read(reader)?.data?.resources.read(reader)); private readonly _isDirtyObservables = mapObservableArrayCached(this, this._resources.map(r => r ?? []), res => { </del> <ins> public readonly resources = derived(this, reader => this._resolvedSource.cachedPromiseResult.read(reader)?.data?.resources.read(reader)); private readonly _isDirtyObservables = mapObservableArrayCached(this, this.resources.map(r => r ?? []), res => { </ins> const isModifiedDirty = res.modified ? isUriDirty(this._textFileService, res.modified) : constObservable(false); const isOriginalDirty = res.original ? isUriDirty(this._textFileService, res.original) : constObservable(false); return derived(reader => /** @description modifiedDirty||originalDirty */ isModifiedDirty.read(reader) || isOriginalDirty.read(reader));


}, 500, false, true)(async (markerEvent) => { markerChanged?.dispose(); markerChanged = undefined; <del> if (!markerEvent.includes(modelEvent.uri) || (this.markerService.read({ resource: modelEvent.uri }).length !== 0)) { </del> <ins> if (!markerEvent || !markerEvent.includes(modelEvent.uri) || (this.markerService.read({ resource: modelEvent.uri }).length !== 0)) { </ins> return; } const oldLines = Array.from(this.lines);


if (this.extensionManagementServerService.localExtensionManagementServer === this.extension.server) { if (this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(this.extension.local.manifest)) { if (this.extensionManagementServerService.remoteExtensionManagementServer) { <del> message = new MarkdownString(`${localize('Install in remote server to enable', "This extension is disabled in this workspace because it is defined to run in the Remote Extension Host. Please install the extension in '{0}' to enable.", this.extensionManagementServerService.remoteExtensionManagementServer.label)} [${localize('learn more', "Learn More")}](https://aka.ms/vscode-remote/developing-extensions/architecture)`); </del> <ins> message = new MarkdownString(`${localize('Install in remote server to enable', "This extension is disabled in this workspace because it is defined to run in the Remote Extension Host. Please install the extension in '{0}' to enable.", this.extensionManagementServerService.remoteExtensionManagementServer.label)} [${localize('learn more', "Learn More")}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`); </ins> } } }


else if (this.extensionManagementServerService.remoteExtensionManagementServer === this.extension.server) { if (this.extensionManifestPropertiesService.prefersExecuteOnUI(this.extension.local.manifest)) { if (this.extensionManagementServerService.localExtensionManagementServer) { <del> message = new MarkdownString(`${localize('Install in local server to enable', "This extension is disabled in this workspace because it is defined to run in the Local Extension Host. Please install the extension locally to enable.", this.extensionManagementServerService.remoteExtensionManagementServer.label)} [${localize('learn more', "Learn More")}](https://aka.ms/vscode-remote/developing-extensions/architecture)`); </del> <ins> message = new MarkdownString(`${localize('Install in local server to enable', "This extension is disabled in this workspace because it is defined to run in the Local Extension Host. Please install the extension locally to enable.", this.extensionManagementServerService.remoteExtensionManagementServer.label)} [${localize('learn more', "Learn More")}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`); </ins> } else if (isWeb) { <del> message = new MarkdownString(`${localize('Defined to run in desktop', "This extension is disabled because it is defined to run only in {0} for the Desktop.", this.productService.nameLong)} [${localize('learn more', "Learn More")}](https://aka.ms/vscode-remote/developing-extensions/architecture)`); </del> <ins> message = new MarkdownString(`${localize('Defined to run in desktop', "This extension is disabled because it is defined to run only in {0} for the Desktop.", this.productService.nameLong)} [${localize('learn more', "Learn More")}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`); </ins> } } } // Extension on Web Server else if (this.extensionManagementServerService.webExtensionManagementServer === this.extension.server) { <del> message = new MarkdownString(`${localize('Cannot be enabled', "This extension is disabled because it is not supported in {0} for the Web.", this.productService.nameLong)} [${localize('learn more', "Learn More")}](https://aka.ms/vscode-remote/developing-extensions/architecture)`); </del> <ins> message = new MarkdownString(`${localize('Cannot be enabled', "This extension is disabled because it is not supported in {0} for the Web.", this.productService.nameLong)} [${localize('learn more', "Learn More")}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`); </ins> } if (message) { this.updateStatus({ icon: warningIcon, message }, true);


const runningExtensionServer = runningExtension ? this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension)) : null; if (this.extension.server === this.extensionManagementServerService.localExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.remoteExtensionManagementServer) { if (this.extensionManifestPropertiesService.prefersExecuteOnWorkspace(this.extension.local.manifest)) { <del> this.updateStatus({ icon: infoIcon, message: new MarkdownString(`${localize('enabled remotely', "This extension is enabled in the Remote Extension Host because it prefers to run there.")} [${localize('learn more', "Learn More")}](https://aka.ms/vscode-remote/developing-extensions/architecture)`) }, true); </del> <ins> this.updateStatus({ icon: infoIcon, message: new MarkdownString(`${localize('enabled remotely', "This extension is enabled in the Remote Extension Host because it prefers to run there.")} [${localize('learn more', "Learn More")}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`) }, true); </ins> } return; } if (this.extension.server === this.extensionManagementServerService.remoteExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.localExtensionManagementServer) { if (this.extensionManifestPropertiesService.prefersExecuteOnUI(this.extension.local.manifest)) { <del> this.updateStatus({ icon: infoIcon, message: new MarkdownString(`${localize('enabled locally', "This extension is enabled in the Local Extension Host because it prefers to run there.")} [${localize('learn more', "Learn More")}](https://aka.ms/vscode-remote/developing-extensions/architecture)`) }, true); </del> <ins> this.updateStatus({ icon: infoIcon, message: new MarkdownString(`${localize('enabled locally', "This extension is enabled in the Local Extension Host because it prefers to run there.")} [${localize('learn more', "Learn More")}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`) }, true); </ins> } return; } if (this.extension.server === this.extensionManagementServerService.remoteExtensionManagementServer && runningExtensionServer === this.extensionManagementServerService.webExtensionManagementServer) { if (this.extensionManifestPropertiesService.canExecuteOnWeb(this.extension.local.manifest)) { <del> this.updateStatus({ icon: infoIcon, message: new MarkdownString(`${localize('enabled in web worker', "This extension is enabled in the Web Worker Extension Host because it prefers to run there.")} [${localize('learn more', "Learn More")}](https://aka.ms/vscode-remote/developing-extensions/architecture)`) }, true); </del> <ins> this.updateStatus({ icon: infoIcon, message: new MarkdownString(`${localize('enabled in web worker', "This extension is enabled in the Web Worker Extension Host because it prefers to run there.")} [${localize('learn more', "Learn More")}](https://code.visualstudio.com/api/advanced-topics/remote-extensions#architecture-and-extension-kinds)`) }, true); </ins> } return; }


when: ContextKeyExpr.or(ContextKeyExpr.and(CONTEXT_IN_CHAT_SESSION, CONTEXT_IN_CHAT_INPUT.negate()), accessibleViewInCodeBlock), primary: KeyMod.CtrlCmd | KeyCode.Enter, mac: { primary: KeyMod.WinCtrl | KeyCode.Enter }, <del> weight: KeybindingWeight.WorkbenchContrib </del> <ins> weight: KeybindingWeight.ExternalExtension + 1 </ins> }, }); }


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


import { editorBackground, editorForeground, inputBackground } from 'vs/platform/theme/common/colorRegistry'; import { ChatModel } from 'vs/workbench/contrib/chat/common/chatModel'; import { Range } from 'vs/editor/common/core/range'; <ins> import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection'; import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; </ins> export class InlineChatContentWidget implements IContentWidget {


constructor( private readonly _editor: ICodeEditor, @IInstantiationService instaService: IInstantiationService, <ins> @IContextKeyService contextKeyService: IContextKeyService, </ins> ) { this._defaultChatModel = this._store.add(instaService.createInstance(ChatModel, `inlineChatDefaultModel/editorContentWidgetPlaceholder`, undefined)); <del> this._widget = instaService.createInstance( </del> <ins> const scopedInstaService = instaService.createChild( new ServiceCollection([ IContextKeyService, this._store.add(contextKeyService.createScoped(this._domNode)) ]) ); this._widget = scopedInstaService.createInstance( </ins> ChatWidget, ChatAgentLocation.Editor, { resource: true },


} return false; }); <del> if (refer && slashCommandLike) { </del> <ins> if (refer && slashCommandLike && !this._session.lastExchange) { </ins> this._log('[IE] seeing refer command, continuing outside editor', this._session.provider.extensionId); // cancel this request


// if agent has a refer command, massage the input to include the agent name await this._instaService.invokeFunction(sendRequest, massagedInput); <del> if (!this._session.lastExchange) { // DONE when there wasn't any exchange yet. We used the inline chat only as trampoline return State.ACCEPT; } return State.WAIT_FOR_INPUT; </del> <ins> return State.ACCEPT; </ins> } this._session.addInput(new SessionPrompt(input, this._nextAttempt, this._nextWithIntentDetection));


import { IChatService } from 'vs/workbench/contrib/chat/common/chatService'; import { setupCustomHover } from 'vs/base/browser/ui/hover/updatableHoverWidget'; import { getDefaultHoverDelegate } from 'vs/base/browser/ui/hover/hoverDelegateFactory'; <ins> import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection'; </ins> export interface InlineChatWidgetViewState {


this._store.add(this._progressBar); let allowRequests = false; <del> this._chatWidget = _instantiationService.createInstance( </del> <ins> const scopedInstaService = _instantiationService.createChild( new ServiceCollection([ IContextKeyService, this._store.add(_contextKeyService.createScoped(this._elements.chatWidget)) ]) ); this._chatWidget = scopedInstaService.createInstance( </ins> ChatWidget, location, { resource: true },


get contentHeight(): number { const data = { followUpsHeight: getTotalHeight(this._elements.followUps), <del> chatWidgetHeight: this._chatWidget.contentHeight, </del> <ins> chatWidgetContentHeight: this._chatWidget.contentHeight, </ins> progressHeight: getTotalHeight(this._elements.progress), statusHeight: getTotalHeight(this._elements.status), extraHeight: this._getExtraHeight() }; <del> const result = data.progressHeight + data.chatWidgetHeight + data.followUpsHeight + data.statusHeight + data.extraHeight; // console.log(`InlineChat#contentHeight ${result}`, data); </del> <ins> const result = data.progressHeight + data.chatWidgetContentHeight + data.followUpsHeight + data.statusHeight + data.extraHeight; </ins> return result; } <ins> get minHeight(): number { // The chat widget is variable height and supports scrolling. It // should be at least 100px high and at most the content height. let value = this.contentHeight; value -= this._chatWidget.contentHeight; value += Math.min(100, this._chatWidget.contentHeight); return value; } </ins> protected _getExtraHeight(): number { return 12 /* padding */ + 2 /*border*/ + 12 /*shadow*/; }


const chatContentHeight = this.widget.contentHeight; const editorHeight = this.editor.getLayoutInfo().height; <del> const contentHeight = Math.min(chatContentHeight, editorHeight * 0.42); </del> <ins> const contentHeight = Math.min(chatContentHeight, Math.max(this.widget.minHeight, editorHeight * 0.42)); </ins> const heightInLines = contentHeight / this.editor.getOption(EditorOption.lineHeight); <del> // console.log('ZONE#_computeHeightInLines', { chatContentHeight, editorHeight, contentHeight, heightInLines }); </del> return heightInLines; }


z-index: 3; } <ins> .monaco-workbench .zone-widget.inline-chat-widget .interactive-session { max-width: unset; } </ins> .monaco-workbench .zone-widget-container.inside-selection { background-color: var(--vscode-inlineChat-regionHighlight); }


background-color: var(--vscode-chat-list-background); } <ins> .interactive-item-container.interactive-request .header .monaco-toolbar { /* Take the partially-transparent background color override for request rows */ background-color: inherit; } </ins> .interactive-item-container .header .monaco-toolbar .checked.action-label, .interactive-item-container .header .monaco-toolbar .checked.action-label:hover { color: var(--vscode-inputOption-activeForeground) !important;


background-color: var(--vscode-inlineChat-regionHighlight); } <del> .monaco-workbench .inline-chat-slash-command { </del> <ins> .monaco-workbench .interactive-session .interactive-input-and-execute-toolbar .monaco-editor .inline-chat-slash-command { </ins> background-color: var(--vscode-chat-slashCommandBackground); <del> color: var(--vscode-chat-slashCommandForeground); </del> <ins> color: var(--vscode-chat-slashCommandForeground); /* Overrides the foreground color rule in chat.css */ </ins> border-radius: 4px; padding: 1px; }


private _getAccessibleViewHelpDialogContent(providerHasSymbols?: boolean): string { const navigationHint = this._getNavigationHint(); const goToSymbolHint = this._getGoToSymbolHint(providerHasSymbols); <del> const toolbarHint = localize('toolbar', "Navigate to the toolbar (Shift+Tab))."); </del> <ins> const toolbarHint = localize('toolbar', "Navigate to the toolbar (Shift+Tab)."); </ins> const chatHints = this._getChatHints(); let hint = localize('intro', "In the accessible view, you can:n");


if (insertIntoNewFileKb) { hint += localize('insertIntoNewFile', " - Insert the code block into a new file ({0}).n", insertIntoNewFileKb); } else { <del> hint += localize('insertIntoNewFileNoKb', " - Insert the code block into a new file by configuring a keybinding for the Chat: Insert at Cursor command.n"); </del> <ins> hint += localize('insertIntoNewFileNoKb', " - Insert the code block into a new file by configuring a keybinding for the Chat: Insert into New File command.n"); </ins> } if (runInTerminalKb) { hint += localize('runInTerminal', " - Run the code block in the terminal ({0}).n", runInTerminalKb);


let goToSymbolHint = ''; if (providerHasSymbols) { if (goToSymbolKb) { <del> goToSymbolHint = localize('goToSymbolHint', 'Go to a symbol ({0})', goToSymbolKb); </del> <ins> goToSymbolHint = localize('goToSymbolHint', 'Go to a symbol ({0}).', goToSymbolKb); </ins> } else { goToSymbolHint = localize('goToSymbolHintNoKb', 'To go to a symbol, configure a keybinding for the command Go To Symbol in Accessible View'); }


// Add default items const productLabel = this.productService.nameLong; const marketPlaceLabel = localize("reportExtensionMarketplace", "Extension Marketplace"); <del> issuePicksConst.push( { label: productLabel, ariaLabel: productLabel, accept: () => this.commandService.executeCommand('workbench.action.openIssueReporter', { issueSource: IssueSource.VSCode }) }, { label: marketPlaceLabel, ariaLabel: marketPlaceLabel, accept: () => this.commandService.executeCommand('workbench.action.openIssueReporter', { issueSource: IssueSource.Marketplace }) }, { type: 'separator', label: localize('extensions', "Extensions") } ); </del> <ins> const productFilter = matchesFuzzy(filter, productLabel, true); const marketPlaceFilter = matchesFuzzy(filter, marketPlaceLabel, true); // Add product pick if product filter matches if (productFilter) { issuePicksConst.push({ label: productLabel, ariaLabel: productLabel, highlights: { label: productFilter }, accept: () => this.commandService.executeCommand('workbench.action.openIssueReporter', { issueSource: IssueSource.VSCode }) }); } // Add marketplace pick if marketplace filter matches if (marketPlaceFilter) { issuePicksConst.push({ label: marketPlaceLabel, ariaLabel: marketPlaceLabel, highlights: { label: marketPlaceFilter }, accept: () => this.commandService.executeCommand('workbench.action.openIssueReporter', { issueSource: IssueSource.Marketplace }) }); } issuePicksConst.push({ type: 'separator', label: localize('extensions', "Extensions") }); </ins> // creates menu from contributed const menu = this.menuService.createMenu(MenuId.IssueReporter, this.contextKeyService);


return; } const contr = TerminalChatController.activeChatWidget || TerminalChatController.get(activeInstance); <del> contr?.chatWidget?.focusResponse(); </del> <ins> contr?.chatWidget?.inlineChatWidget.chatWidget.focusLastMessage(); </ins> } });


focus(): void { this._inlineChatWidget.focus(); } <del> focusResponse(): void { const responseElement = this._inlineChatWidget.domNode.querySelector(ChatElementSelectors.ResponseEditor) || this._inlineChatWidget.domNode.querySelector(ChatElementSelectors.ResponseMessage); if (responseElement instanceof HTMLElement) { responseElement.focus(); } } </del> hasFocus(): boolean { return this._inlineChatWidget.hasFocus(); }


} } <del> const enum ChatElementSelectors { ResponseEditor = '.chatMessageContent textarea', ResponseMessage = '.chatMessageContent', } </del>


// Import the effects we need import { Color } from 'vs/base/common/color'; <del> import { registerColor, darken, lighten, ifDefinedThenElse, transparent } from 'vs/platform/theme/common/colorUtils'; </del> <ins> import { registerColor, darken, lighten, transparent } from 'vs/platform/theme/common/colorUtils'; </ins> // Import the colors we need import { foreground, contrastBorder, activeContrastBorder, focusBorder, iconForeground } from 'vs/platform/theme/common/colors/baseColors';


nls.localize('highlight', 'List/Tree foreground color of the match highlights when searching inside the list/tree.')); export const listFocusHighlightForeground = registerColor('list.focusHighlightForeground', <del> { dark: listHighlightForeground, light: ifDefinedThenElse(listActiveSelectionBackground, listHighlightForeground, '#BBE7FF'), hcDark: listHighlightForeground, hcLight: listHighlightForeground }, </del> <ins> { dark: listHighlightForeground, light: listHighlightForeground, hcDark: listHighlightForeground, hcLight: listHighlightForeground }, </ins> nls.localize('listFocusHighlightForeground', 'List/Tree foreground color of the match highlights on actively focused items when searching inside the list/tree.')); export const listInvalidItemForeground = registerColor('list.invalidItemForeground',


import { Emitter, Event } from 'vs/base/common/event'; import { DisposableStore } from 'vs/base/common/lifecycle'; import { IPosition, Position } from 'vs/editor/common/core/position'; <del> import { clamp } from 'vs/base/common/numbers'; </del> import { renderLabelWithIcons } from 'vs/base/browser/ui/iconLabel/iconLabels'; import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; import { inlineChatBackground } from 'vs/workbench/contrib/inlineChat/common/inlineChat';


import { Range } from 'vs/editor/common/core/range'; import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection'; import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; <ins> import { EditorOption } from 'vs/editor/common/config/editorOptions'; </ins> export class InlineChatContentWidget implements IContentWidget {


beforeRender(): IDimension | null { <del> const contentWidth = this._editor.getLayoutInfo().contentWidth; const minWidth = Math.round(contentWidth * 0.38); const maxWidth = Math.round(contentWidth * 0.82); const width = clamp(220, minWidth, maxWidth); </del> <ins> const maxHeight = this._widget.input.inputEditor.getOption(EditorOption.lineHeight) * 5; </ins> const inputEditorHeight = this._widget.inputEditor.getContentHeight(); <del> this._widget.inputEditor.layout(new dom.Dimension(width, inputEditorHeight)); </del> <ins> this._widget.inputEditor.layout(new dom.Dimension(360, Math.min(maxHeight, inputEditorHeight))); </ins> // const actualHeight = this._widget.inputPartHeight; // return new dom.Dimension(width, actualHeight);


display: none; } <ins> .monaco-workbench .inline-chat-content-widget.interactive-session .interactive-session { max-width: unset; } </ins> .monaco-workbench .inline-chat-content-widget.interactive-session .interactive-input-part .interactive-execute-toolbar { margin-bottom: 1px; }


import { Codicon } from 'vs/base/common/codicons'; import { ThemeIcon } from 'vs/base/common/themables'; import { onUnexpectedExternalError } from 'vs/base/common/errors'; <del> import { getDefaultHoverDelegate } from 'vs/base/browser/ui/hover/hoverDelegateFactory'; </del> import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; <del> import { ClickAction, KeyDownAction } from 'vs/base/browser/ui/hover/hoverWidget'; </del> <ins> import { ClickAction, HoverPosition, KeyDownAction } from 'vs/base/browser/ui/hover/hoverWidget'; </ins> import { KeyCode } from 'vs/base/common/keyCodes'; <del> import { IHoverService } from 'vs/platform/hover/browser/hover'; </del> <ins> import { IHoverService, WorkbenchHoverDelegate } from 'vs/platform/hover/browser/hover'; </ins> import { AsyncIterableObject } from 'vs/base/common/async'; import { LanguageFeatureRegistry } from 'vs/editor/common/languageFeatureRegistry'; import { getHoverProviderResultsAsAsyncIterable } from 'vs/editor/contrib/hover/browser/getHover';


this._openerService, this._keybindingService, this._hoverService, <ins> this._configurationService, </ins> context.onContentsChanged ); return this._renderedHoverParts;


private readonly _openerService: IOpenerService, private readonly _keybindingService: IKeybindingService, private readonly _hoverService: IHoverService, <ins> private readonly _configurationService: IConfigurationService, </ins> private readonly _onFinishedRendering: () => void, ) { super();


const isActionIncrease = action === HoverVerbosityAction.Increase; const actionElement = dom.append(container, $(ThemeIcon.asCSSSelector(isActionIncrease ? increaseHoverVerbosityIcon : decreaseHoverVerbosityIcon))); actionElement.tabIndex = 0; <ins> const hoverDelegate = new WorkbenchHoverDelegate('mouse', false, { target: container, position: { hoverPosition: HoverPosition.LEFT } }, this._configurationService, this._hoverService); </ins> if (isActionIncrease) { const kb = this._keybindingService.lookupKeybinding(INCREASE_HOVER_VERBOSITY_ACTION_ID); <del> store.add(this._hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), actionElement, kb ? </del> <ins> store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, kb ? </ins> nls.localize('increaseVerbosityWithKb', "Increase Verbosity ({0})", kb.getLabel()) : nls.localize('increaseVerbosity', "Increase Verbosity"))); } else { const kb = this._keybindingService.lookupKeybinding(DECREASE_HOVER_VERBOSITY_ACTION_ID); <del> store.add(this._hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), actionElement, kb ? </del> <ins> store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, kb ? </ins> nls.localize('decreaseVerbosityWithKb', "Decrease Verbosity ({0})", kb.getLabel()) : nls.localize('decreaseVerbosity', "Decrease Verbosity"))); }


comment: ['Label for action that will increase the hover verbosity level.'] }, "Increase Hover Verbosity Level"), alias: 'Increase Hover Verbosity Level', <del> precondition: EditorContextKeys.hoverFocused, kbOpts: { kbExpr: EditorContextKeys.hoverFocused, primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.KeyP), weight: KeybindingWeight.EditorContrib } </del> <ins> precondition: EditorContextKeys.hoverFocused </ins> }); }


comment: ['Label for action that will decrease the hover verbosity level.'] }, "Decrease Hover Verbosity Level"), alias: 'Decrease Hover Verbosity Level', <del> precondition: EditorContextKeys.hoverFocused, kbOpts: { kbExpr: EditorContextKeys.hoverFocused, primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.KeyM), weight: KeybindingWeight.EditorContrib } </del> <ins> precondition: EditorContextKeys.hoverFocused </ins> }); }


const fullscreen = isFullscreen(this.window); return { ...state, <del> bounds: this.maximized ? undefined : state.bounds, // ignore if maximized (fullscreen is not yet supported!) </del> <ins> bounds: state.bounds, </ins> mode: this.maximized ? AuxiliaryWindowMode.Maximized : fullscreen ? AuxiliaryWindowMode.Fullscreen : AuxiliaryWindowMode.Normal }; }


$completionPrefix = $commandLine # Get completions <del> $result = "`e]633;Completions" </del> <ins> $result = "$([char]0x1b)]633;Completions" </ins> if ($completionPrefix.Length -gt 0) { # Get and send completions $completions = TabExpansion2 -inputScript $completionPrefix -cursorColumn $cursorIndex


import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { IMarkerService } from 'vs/platform/markers/common/markers'; import { IThemeService } from 'vs/platform/theme/common/themeService'; <del> import { IActiveNotebookEditor, ICellViewModel, INotebookEditor, type INotebookViewCellsUpdateEvent } from 'vs/workbench/contrib/notebook/browser/notebookBrowser'; </del> <ins> import { IActiveNotebookEditor, ICellViewModel, INotebookEditor } from 'vs/workbench/contrib/notebook/browser/notebookBrowser'; </ins> import { CellKind, NotebookCellsChangeType, NotebookSetting } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { INotebookExecutionStateService, NotebookExecutionType } from 'vs/workbench/contrib/notebook/common/notebookExecutionStateService'; import { OutlineChangeEvent, OutlineConfigKeys, OutlineTarget } from 'vs/workbench/services/outline/browser/outline';


private _uri: URI | undefined; private _entries: OutlineEntry[] = []; get entries(): OutlineEntry[] { <ins> if (this.delayedOutlineRecompute.isTriggered()) { this.delayedOutlineRecompute.cancel(); this._recomputeState(); } </ins> return this._entries; }


readonly outlineKind = 'notebookCells'; get activeElement(): OutlineEntry | undefined { <ins> if (this.delayedOutlineRecompute.isTriggered()) { this.delayedOutlineRecompute.cancel(); this._recomputeState(); } </ins> return this._activeEntry; } private readonly _outlineEntryFactory: NotebookOutlineEntryFactory; <del> private readonly delayRecomputeActive: () => void; </del> <ins> private readonly delayedOutlineRecompute: Delayer<void>;; </ins> constructor( private readonly _editor: INotebookEditor, private readonly _target: OutlineTarget,


@IConfigurationService private readonly _configurationService: IConfigurationService, ) { this._outlineEntryFactory = new NotebookOutlineEntryFactory(notebookExecutionStateService); <del> const delayerRecomputeActive = this._disposables.add(new Delayer(10)); this.delayRecomputeActive = () => delayerRecomputeActive.trigger(() => this._recomputeActive()); this._disposables.add(Event.debounce<void, void>( _editor.onDidChangeSelection, (last, _current) => last, 200 )(() => { this.delayRecomputeActive(); </del> <ins> const delayerRecomputeActive = this._disposables.add(new Delayer(200)); this._disposables.add(_editor.onDidChangeSelection(() => { delayerRecomputeActive.trigger(() => this._recomputeActive()); </ins> }, this)) <del> this._disposables.add(Event.debounce<INotebookViewCellsUpdateEvent, INotebookViewCellsUpdateEvent>( _editor.onDidChangeViewCells, (last, _current) => last ?? _current, 200 )(() => { this.delayRecomputeActive(); }, this) ); </del> // .3s of a delay is sufficient, 100-200s is too quick and will unnecessarily block the ui thread. // Given we're only updating the outline when the user types, we can afford to wait a bit. <del> const delayer = this._disposables.add(new Delayer<void>(300)); const delayedRecompute = () => delayer.trigger(() => this._recomputeState()); </del> <ins> this.delayedOutlineRecompute = this._disposables.add(new Delayer<void>(300)); const delayedRecompute = () => { delayerRecomputeActive.cancel(); // Active is always recomputed after a recomputing the outline state. this.delayedOutlineRecompute.trigger(() => this._recomputeState()); }; </ins> this._disposables.add(_configurationService.onDidChangeConfiguration(e => { if (e.affectsConfiguration(NotebookSetting.outlineShowMarkdownHeadersOnly) ||


return; } disposable.add(this._editor.textModel.onDidChangeContent(contentChanges => { <del> if (contentChanges.rawEvents.some(c => c.kind === NotebookCellsChangeType.ChangeCellContent)) { </del> <ins> if (contentChanges.rawEvents.some(c => c.kind === NotebookCellsChangeType.ChangeCellContent || c.kind === NotebookCellsChangeType.ChangeCellInternalMetadata || c.kind === NotebookCellsChangeType.Move || c.kind === NotebookCellsChangeType.ModelChange)) { </ins> delayedRecompute(); } }));


} })); <del> this.delayRecomputeActive(); </del> <ins> this._recomputeActive(); </ins> } private _recomputeActive(): { changeEventTriggered: boolean } {


let customEditorLabelDescription = localize('workbench.editor.label.patterns', "Controls the rendering of the editor label. Each __Item__ is a pattern that matches a file path. Both relative and absolute file paths are supported. In case multiple patterns match, the longest matching path will be picked. Each __Value__ is the template for the rendered editor when the __Item__ matches. Variables are substituted based on the context:"); customEditorLabelDescription += 'n- ' + [ localize('workbench.editor.label.dirname', "`${dirname}`: name of the folder in which the file is located (e.g. `root/folder/file.txt -> folder`)."), <del> localize('workbench.editor.label.nthdirname', "`${dirname(N)}`: name of the nth parent folder in which the file is located (e.g. `N=1: root/folder/file.txt -> root`)."), </del> <ins> localize('workbench.editor.label.nthdirname', "`${dirname(N)}`: name of the nth parent folder in which the file is located (e.g. `N=1: root/folder/file.txt -> root`). Folders can be picked from the start of the path by using negative numbers (e.g. `N=-1: root/folder/file.txt -> root`). If the __Item__ is an absolute pattern path, the first folder (`N=-1`) refers to the first folder in the absoulte path, otherwise it corresponds to the workspace folder."), </ins> localize('workbench.editor.label.filename', "`${filename}`: name of the file without the file extension (e.g. `root/folder/file.txt -> file`)."), localize('workbench.editor.label.extname', "`${extname}`: the file extension (e.g. `root/folder/file.txt -> txt`)."), ].join('n- '); // intentionally concatenated to not produce a string that is too long for translations


import { MainThreadTunnelServiceShape, MainContext, ExtHostContext, ExtHostTunnelServiceShape, CandidatePortSource, PortAttributesSelector, TunnelDto } from 'vs/workbench/api/common/extHost.protocol'; import { TunnelDtoConverter } from 'vs/workbench/api/common/extHostTunnelService'; import { extHostNamedCustomer, IExtHostContext } from 'vs/workbench/services/extensions/common/extHostCustomers'; <del> import { IRemoteExplorerService, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_OUTPUT } from 'vs/workbench/services/remote/common/remoteExplorerService'; </del> <ins> import { IRemoteExplorerService, PORT_AUTO_FORWARD_SETTING, PORT_AUTO_SOURCE_SETTING, PORT_AUTO_SOURCE_SETTING_HYBRID, PORT_AUTO_SOURCE_SETTING_OUTPUT } from 'vs/workbench/services/remote/common/remoteExplorerService'; </ins> import { ITunnelProvider, ITunnelService, TunnelCreationOptions, TunnelProviderFeatures, TunnelOptions, RemoteTunnel, ProvidedPortAttributes, PortAttributesProvider, TunnelProtocol } from 'vs/platform/tunnel/common/tunnel'; import { Disposable } from 'vs/base/common/lifecycle'; import type { TunnelDescription } from 'vs/platform/remote/common/remoteAuthorityResolver';


.registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_OUTPUT } }]); break; } <ins> case CandidatePortSource.Hybrid: { Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration) .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_HYBRID } }]); break; } </ins> default: // Do nothing, the defaults for these settings should be used. } }).catch(() => {


export enum CandidatePortSource { None = 0, Process = 1, <del> Output = 2 </del> <ins> Output = 2, Hybrid = 3 </ins> } export interface PortAttributesSelector {


export enum CandidatePortSource { None = 0, Process = 1, <del> Output = 2 </del> <ins> Output = 2, Hybrid = 3 </ins> } export type ResolverResult = (ResolvedAuthority | ManagedResolvedAuthority) & ResolvedOptions & TunnelInformation;


} private toSymbolInformation(item: Proto.NavtoItem): vscode.SymbolInformation | undefined { <del> if (!item.containerName || item.kind === 'alias') { </del> <ins> if (item.kind === 'alias' && !item.containerName) { </ins> return; }


"--vscode-editorStickyScroll-scrollableWidth", "--vscode-editorStickyScroll-foldingOpacityTransition", "--window-border-color", <ins> "--vscode-parameterHintsWidget-editorFontFamily", "--vscode-parameterHintsWidget-editorFontFamilyDefault", </ins> "--workspace-trust-check-color", "--workspace-trust-selected-color", "--workspace-trust-unselected-color",


border-bottom: 1px solid var(--vscode-editorHoverWidget-border); } <ins> .monaco-editor .parameter-hints-widget .code { font-family: var(--vscode-parameterHintsWidget-editorFontFamily), var(--vscode-parameterHintsWidget-editorFontFamilyDefault); } </ins> .monaco-editor .parameter-hints-widget .docs { padding: 0 10px 0 5px; white-space: pre-wrap;


import { assertIsDefined } from 'vs/base/common/types'; import 'vs/css!./parameterHints'; import { ContentWidgetPositionPreference, ICodeEditor, IContentWidget, IContentWidgetPosition } from 'vs/editor/browser/editorBrowser'; <del> import { EditorOption } from 'vs/editor/common/config/editorOptions'; </del> <ins> import { EDITOR_FONT_DEFAULTS, EditorOption } from 'vs/editor/common/config/editorOptions'; </ins> import * as languages from 'vs/editor/common/languages'; import { ILanguageService } from 'vs/editor/common/languages/language'; import { IMarkdownRenderResult, MarkdownRenderer } from 'vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';


if (!this.domNodes) { return; } const fontInfo = this.editor.getOption(EditorOption.fontInfo); <del> this.domNodes.element.style.fontSize = `${fontInfo.fontSize}px`; this.domNodes.element.style.lineHeight = `${fontInfo.lineHeight / fontInfo.fontSize}`; </del> <ins> const element = this.domNodes.element; element.style.fontSize = `${fontInfo.fontSize}px`; element.style.lineHeight = `${fontInfo.lineHeight / fontInfo.fontSize}`; element.style.setProperty('--vscode-parameterHintsWidget-editorFontFamily', fontInfo.fontFamily); element.style.setProperty('--vscode-parameterHintsWidget-editorFontFamilyDefault', EDITOR_FONT_DEFAULTS.fontFamily); </ins> }; updateFont();


} const code = dom.append(this.domNodes.signature, $('.code')); <del> const fontInfo = this.editor.getOption(EditorOption.fontInfo); code.style.fontSize = `${fontInfo.fontSize}px`; code.style.fontFamily = fontInfo.fontFamily; </del> const hasParameters = signature.parameters.length > 0; const activeParameterIndex = signature.activeParameter ?? hints.activeParameter;


function Global:__VSCode-Escape-Value([string]$value) { # NOTE: In PowerShell v6.1+, this can be written `$value -replace '…', { … }` instead of `[regex]::Replace`. # Replace any non-alphanumeric characters. <del> [regex]::Replace($value, "[$([char]0x1b)n;]", { param($match) </del> <ins> [regex]::Replace($value, "[$([char]0x00)-$([char]0x1f)n;]", { param($match) </ins> # Encode the (ascii) matches as `x<hex>` -Join ( [System.Text.Encoding]::UTF8.GetBytes($match.Value) | ForEach-Object { 'x{0:x2}' -f $_ }


this._scanDevelopedExtensions(language, extensionDevelopmentPath) ]); <del> return dedupExtensions(builtinExtensions, [...installedExtensions, ...workspaceInstalledExtensions], developedExtensions, this._logService); </del> <ins> return dedupExtensions(builtinExtensions, installedExtensions, workspaceInstalledExtensions, developedExtensions, this._logService); </ins> } private async _scanDevelopedExtensions(language: string, extensionDevelopmentPaths?: string[]): Promise<IExtensionDescription[]> {


all.push(...await this.workbenchExtensionManagementService.getInstalledWorkspaceExtensions(true)); } <del> // dedup user and system extensions by giving priority to user extensions. </del> <ins> // dedup workspace, user and system extensions by giving priority to workspace first and then to user extension. </ins> const installed = groupByExtension(all, r => r.identifier).reduce((result, extensions) => { <del> const extension = extensions.length === 1 ? extensions[0] : extensions.find(e => e.type === ExtensionType.User) || extensions.find(e => e.type === ExtensionType.System); result.push(extension!); </del> <ins> if (extensions.length === 1) { result.push(extensions[0]); } else { let workspaceExtension: ILocalExtension | undefined, userExtension: ILocalExtension | undefined, systemExtension: ILocalExtension | undefined; for (const extension of extensions) { if (extension.isWorkspaceScoped) { workspaceExtension = extension; } else if (extension.type === ExtensionType.User) { userExtension = extension; } else { systemExtension = extension; } } const extension = workspaceExtension ?? userExtension ?? systemExtension; if (extension) { result.push(extension); } } </ins> return result; }, []);


if (isUninstalled) { const canRemoveRunningExtension = runningExtension && this.extensionService.canRemoveExtension(runningExtension); <del> const isSameExtensionRunning = runningExtension && (!extension.server || extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension))); </del> <ins> const isSameExtensionRunning = runningExtension && (!extension.server || extension.server === this.extensionManagementServerService.getExtensionManagementServer(toExtension(runningExtension))) && (!extension.resourceExtension || this.uriIdentityService.extUri.isEqual(extension.resourceExtension.location, runningExtension.extensionLocation)); </ins> if (!canRemoveRunningExtension && isSameExtensionRunning && !runningExtension.isUnderDevelopment) { return { action: reloadAction, reason: nls.localize('postUninstallTooltip', "Please {0} to complete the uninstallation of this extension.", reloadActionLabel) }; }


} catch (error) { this._logService.error(error); } <del> return dedupExtensions(system, user, development, this._logService); </del> <ins> return dedupExtensions(system, user, [], development, this._logService); </ins> } protected async _resolveExtensionsDefault() {


import * as semver from 'vs/base/common/semver/semver'; // TODO: @sandy081 merge this with deduping in extensionsScannerService.ts <del> export function dedupExtensions(system: IExtensionDescription[], user: IExtensionDescription[], development: IExtensionDescription[], logService: ILogService): IExtensionDescription[] { </del> <ins> export function dedupExtensions(system: IExtensionDescription[], user: IExtensionDescription[], workspace: IExtensionDescription[], development: IExtensionDescription[], logService: ILogService): IExtensionDescription[] { </ins> const result = new ExtensionIdentifierMap<IExtensionDescription>(); system.forEach((systemExtension) => { const extension = result.get(systemExtension.identifier);


} result.set(userExtension.identifier, userExtension); }); <ins> workspace.forEach(workspaceExtension => { const extension = result.get(workspaceExtension.identifier); if (extension) { logService.warn(localize('overwritingWithWorkspaceExtension', "Overwriting {0} with Workspace Extension {1}.", extension.extensionLocation.fsPath, workspaceExtension.extensionLocation.fsPath)); } result.set(workspaceExtension.identifier, workspaceExtension); }); </ins> development.forEach(developedExtension => { logService.info(localize('extensionUnderDevelopment', "Loading development extension at {0}", developedExtension.extensionLocation.fsPath)); const extension = result.get(developedExtension.identifier);


} const system = scannedSystemExtensions.map(e => toExtensionDescriptionFromScannedExtension(e, false)); <del> const userGlobal = scannedUserExtensions.map(e => toExtensionDescriptionFromScannedExtension(e, false)); const userWorkspace = workspaceExtensions.map(e => toExtensionDescription(e, false)); </del> <ins> const user = scannedUserExtensions.map(e => toExtensionDescriptionFromScannedExtension(e, false)); const workspace = workspaceExtensions.map(e => toExtensionDescription(e, false)); </ins> const development = scannedDevelopedExtensions.map(e => toExtensionDescriptionFromScannedExtension(e, true)); <del> const r = dedupExtensions(system, [...userGlobal, ...userWorkspace], development, this._logService); </del> <ins> const r = dedupExtensions(system, user, workspace, development, this._logService); </ins> if (!hasErrors) { const disposable = this._extensionsScannerService.onDidChangeCache(() => {


class MenuInfoSnapshot { protected _menuGroups: MenuItemGroup[] = []; <ins> private _allMenuIds: Set<MenuId> = new Set(); </ins> private _structureContextKeys: Set<string> = new Set(); private _preconditionContextKeys: Set<string> = new Set(); private _toggledContextKeys: Set<string> = new Set();


protected readonly _collectContextKeysForSubmenus: boolean, ) { this.refresh(); <ins> this._allMenuIds.add(_id); } get allMenuIds(): ReadonlySet<MenuId> { return this._allMenuIds; </ins> } get structureContextKeys(): ReadonlySet<string> {


// reset this._menuGroups.length = 0; <ins> this._allMenuIds.clear(); </ins> this._structureContextKeys.clear(); this._preconditionContextKeys.clear(); this._toggledContextKeys.clear();


} group[1].push(item); <del> // keep keys for eventing this._collectContextKeys(item); </del> <ins> // keep keys and submenu ids for eventing this._collectContextKeysAndSubmenuIds(item); </ins> } }


return menuItems; } <del> private _collectContextKeys(item: IMenuItem | ISubmenuItem): void { </del> <ins> private _collectContextKeysAndSubmenuIds(item: IMenuItem | ISubmenuItem): void { </ins> MenuInfoSnapshot._fillInKbExprKeys(item.when, this._structureContextKeys);


} else if (this._collectContextKeysForSubmenus) { // recursively collect context keys from submenus so that this // menu fires events when context key changes affect submenus <del> MenuRegistry.getMenuItems(item.submenu).forEach(this._collectContextKeys, this); </del> <ins> MenuRegistry.getMenuItems(item.submenu).forEach(this._collectContextKeysAndSubmenuIds, this); this._allMenuIds.add(item.submenu); </ins> } }


}, options.eventDebounceDelay); this._disposables.add(rebuildMenuSoon); this._disposables.add(MenuRegistry.onDidChangeMenu(e => { <del> if (e.has(id)) { rebuildMenuSoon.schedule(); </del> <ins> for (const id of this._menuInfo.allMenuIds) { if (e.has(id)) { rebuildMenuSoon.schedule(); break; } </ins> } }));


"sourceMap": false, "allowJs": true, "resolveJsonModule": true, <ins> "isolatedModules": true, </ins> "outDir": "../out/vs", "types": [ "mocha",


*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> declare const enum LoaderEventType { </del> <ins> declare enum LoaderEventType { </ins> LoaderAvailable = 1, BeginLoadingScript = 10,


import { CommandOptions, ForkOptions, Source, SuccessData, TerminateResponse, TerminateResponseCode } from 'vs/base/common/processes'; import * as Types from 'vs/base/common/types'; import * as pfs from 'vs/base/node/pfs'; <del> export { CommandOptions, ForkOptions, SuccessData, Source, TerminateResponse, TerminateResponseCode }; </del> <ins> export { type CommandOptions, type ForkOptions, type SuccessData, Source, type TerminateResponse, TerminateResponseCode }; </ins> export type ValueCallback<T> = (value: T | Promise<T>) => void; export type ErrorCallback = (error?: any) => void;


import { RawContextKey } from 'vs/platform/contextkey/common/contextkey'; import { workbenchConfigurationNodeBase, Extensions as WorkbenchExtensions, IConfigurationMigrationRegistry, ConfigurationKeyValuePairs, ConfigurationMigration } from 'vs/workbench/common/configuration'; import { AccessibilitySignal } from 'vs/platform/accessibilitySignal/browser/accessibilitySignalService'; <del> import { ISpeechService, SPEECH_LANGUAGES, SPEECH_LANGUAGE_CONFIG } from 'vs/workbench/contrib/speech/common/speechService'; </del> <ins> import { AccessibilityVoiceSettingId, ISpeechService, SPEECH_LANGUAGES } from 'vs/workbench/contrib/speech/common/speechService'; </ins> import { Disposable } from 'vs/base/common/lifecycle'; import { IWorkbenchContribution } from 'vs/workbench/common/contributions'; import { Event } from 'vs/base/common/event';


}); } <del> export const enum AccessibilityVoiceSettingId { SpeechTimeout = 'accessibility.voice.speechTimeout', AutoSynthesize = 'accessibility.voice.autoSynthesize', SpeechLanguage = SPEECH_LANGUAGE_CONFIG } </del> <ins> export { AccessibilityVoiceSettingId } </ins> export const SpeechTimeoutDefault = 1200; export class DynamicSpeechAccessibilityConfiguration extends Disposable implements IWorkbenchContribution {


export const INLINE_CHAT_ID = 'interactiveEditor'; export const INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID = 'interactiveEditorAccessiblityHelp'; <ins> export const enum EditMode { Live = 'live', Preview = 'preview' } </ins> export const CTX_INLINE_CHAT_HAS_PROVIDER = new RawContextKey<boolean>('inlineChatHasProvider', false, localize('inlineChatHasProvider', "Whether a provider for interactive editors exists")); export const CTX_INLINE_CHAT_VISIBLE = new RawContextKey<boolean>('inlineChatVisible', false, localize('inlineChatVisible', "Whether the interactive editor input is visible")); export const CTX_INLINE_CHAT_FOCUSED = new RawContextKey<boolean>('inlineChatFocused', false, localize('inlineChatFocused', "Whether the interactive editor input is focused"));


// settings <del> export const enum EditMode { Live = 'live', Preview = 'preview' } </del> Registry.as<IConfigurationMigrationRegistry>(ExtensionsMigration.ConfigurationMigration).registerConfigurationMigrations( [{


recognizeKeyword(token: CancellationToken): Promise<KeywordRecognitionStatus>; } <del> export const SPEECH_LANGUAGE_CONFIG = 'accessibility.voice.speechLanguage'; </del> <ins> export const enum AccessibilityVoiceSettingId { SpeechTimeout = 'accessibility.voice.speechTimeout', AutoSynthesize = 'accessibility.voice.autoSynthesize', SpeechLanguage = 'accessibility.voice.speechLanguage', } export const SPEECH_LANGUAGE_CONFIG = AccessibilityVoiceSettingId.SpeechLanguage; </ins> export const SPEECH_LANGUAGES = { ['da-DK']: {


import { IStringDictionary } from 'vs/base/common/collections'; import { RawContextKey, ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey'; <del> export { ITaskSummary, Task, ITaskTerminateResponse as TaskTerminateResponse }; </del> <ins> export type { ITaskSummary, Task, ITaskTerminateResponse as TaskTerminateResponse }; </ins> export const CustomExecutionSupportedContext = new RawContextKey<boolean>('customExecutionSupported', false, nls.localize('tasks.customExecutionSupported', "Whether CustomExecution tasks are supported. Consider using in the when clause of a 'taskDefinition' contribution.")); export const ShellExecutionSupportedContext = new RawContextKey<boolean>('shellExecutionSupported', false, nls.localize('tasks.shellExecutionSupported', "Whether ShellExecution tasks are supported. Consider using in the when clause of a 'taskDefinition' contribution."));


} .interactive-session .chat-attached-context { <del> padding: 8px 8px 13px; margin-right: -3px; margin-top: 4px; margin-bottom: -4px; border: 1px solid var(--vscode-input-border, var(--vscode-input-background, transparent)); border-radius: 6px 6px 0px 0px; </del> <ins> padding: 8px 0; border-radius: 6px; </ins> display: flex; gap: 4px; flex-wrap: wrap; } .interactive-session .chat-attached-context .chat-attached-context-attachment { <del> padding: 3px; border: 1px solid var(--vscode-input-border, var(--vscode-input-background, transparent)); </del> <ins> padding: 2px; border: 1px solid var(--vscode-chat-requestBorder, var(--vscode-input-background, transparent)); </ins> border-radius: 5px; <del> height: 20px; </del> <ins> height: 18px; </ins> } .interactive-session-followups {


switch (state) { case VoiceChatSessionState.GettingReady: contextVoiceChatGettingReady.set(true); <del> contextVoiceChatInProgress.set(undefined); </del> <ins> contextVoiceChatInProgress.reset(); </ins> break; case VoiceChatSessionState.Started: <del> contextVoiceChatGettingReady.set(false); </del> <ins> contextVoiceChatGettingReady.reset(); </ins> contextVoiceChatInProgress.set(context); break; case VoiceChatSessionState.Stopped: <del> contextVoiceChatGettingReady.set(false); contextVoiceChatInProgress.set(undefined); </del> <ins> contextVoiceChatGettingReady.reset(); contextVoiceChatInProgress.reset(); </ins> break; } };


f1: true, keybinding: { weight: KeybindingWeight.WorkbenchContrib + 100, <del> primary: KeyCode.Escape </del> <ins> primary: KeyCode.Escape, when: AnyScopedVoiceChatInProgress </ins> }, icon: spinningLoading, precondition: GlobalVoiceChatInProgress, // need global context here because of `f1: true`


disposables.add(controller.onDidHideChat(() => this.stop())); const scopedChatToSpeechInProgress = ScopedChatSynthesisInProgress.bindTo(controller.contextKeyService); <del> disposables.add(toDisposable(() => scopedChatToSpeechInProgress.set(false))); </del> <ins> disposables.add(toDisposable(() => scopedChatToSpeechInProgress.reset())); </ins> disposables.add(session.onDidChange(e => { switch (e.status) {


scopedChatToSpeechInProgress.set(true); break; case TextToSpeechStatus.Stopped: <del> scopedChatToSpeechInProgress.set(false); </del> <ins> scopedChatToSpeechInProgress.reset(); </ins> break; } }));


keybinding: { weight: KeybindingWeight.WorkbenchContrib + 100, primary: KeyCode.Escape, <ins> when: ScopedChatSynthesisInProgress </ins> }, menu: [ {


enable: true }, ProgressLocation.Notification); } finally { <del> InstallingSpeechProvider.bindTo(contextKeyService).set(false); </del> <ins> InstallingSpeechProvider.bindTo(contextKeyService).reset(); </ins> } }