import { AccessibleViewType, AdvancedContentProvider, ExtensionContentProvider } from 'vs/platform/accessibility/browser/accessibleView'; import { ContextKeyExpression } from 'vs/platform/contextkey/common/contextkey'; import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation'; <ins> import { alert } from 'vs/base/browser/ui/aria/aria'; </ins> export interface IAccessibleViewImplentation { type: AccessibleViewType;


inBlock = true; startLine = i + 1; languageId = line.substring(3).trim(); <del> } else if (inBlock && line.startsWith('```')) { </del> <ins> } else if (inBlock && line.endsWith('```')) { </ins> inBlock = false; const endLine = i; const code = lines.slice(startLine, endLine).join('n');


menu: { ...accessibleViewMenu, <del> when: ContextKeyExpr.and(accessibleViewIsShown, accessibleViewSupportsNavigation), </del> <ins> when: ContextKeyExpr.and(accessibleViewIsShown, accessibleViewContainsCodeBlocks), </ins> }, title: localize('editor.action.accessibleViewNextCodeBlock', "Accessible View: Next Code Block") });


icon: Codicon.arrowLeft, menu: { ...accessibleViewMenu, <del> when: ContextKeyExpr.and(accessibleViewIsShown, accessibleViewSupportsNavigation), </del> <ins> when: ContextKeyExpr.and(accessibleViewIsShown, accessibleViewContainsCodeBlocks), </ins> }, title: localize('editor.action.accessibleViewPreviousCodeBlock', "Accessible View: Previous Code Block") });


*--------------------------------------------------------------------------------------------*/ import * as DOM from '../../../../../../base/browser/dom.js'; <del> import { ICellViewModel } from '../../notebookBrowser.js'; </del> <ins> import { ICellViewModel, INotebookEditorDelegate } from '../../notebookBrowser.js'; </ins> import { CellContentPart } from '../cellPart.js'; export class CellDecorations extends CellContentPart { constructor( <ins> readonly notebookEditor: INotebookEditorDelegate, </ins> readonly rootContainer: HTMLElement, readonly decorationContainer: HTMLElement, ) {


})); generateCellTopDecorations(); <ins> this.registerDecorations(); } private registerDecorations() { if (!this.currentCell) { return; } this.cellDisposables.add(this.currentCell.onCellDecorationsChanged((e) => { e.added.forEach(options => { if (options.className && this.currentCell) { this.rootContainer.classList.add(options.className); this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [options.className], []); } if (options.outputClassName && this.currentCell) { this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [options.outputClassName], []); } }); e.removed.forEach(options => { if (options.className && this.currentCell) { this.rootContainer.classList.remove(options.className); this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [], [options.className]); } if (options.outputClassName && this.currentCell) { this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [], [options.outputClassName]); } }); })); this.currentCell.getCellDecorations().forEach(options => { if (options.className && this.currentCell) { this.rootContainer.classList.add(options.className); this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [options.className], []); } if (options.outputClassName && this.currentCell) { this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [options.outputClassName], []); } }); </ins> } }


this.registerNotebookEditorListeners(); this.registerViewCellLayoutChange(); this.registerCellEditorEventListeners(); <del> this.registerDecorations(); </del> this.registerMouseListener(); this._register(Event.any(this.viewCell.onDidStartExecution, this.viewCell.onDidStopExecution)((e) => {


})); } <del> private registerDecorations() { // Apply decorations this._register(this.viewCell.onCellDecorationsChanged((e) => { e.added.forEach(options => { if (options.className) { this.templateData.rootContainer.classList.add(options.className); } if (options.outputClassName) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [options.outputClassName], []); } }); e.removed.forEach(options => { if (options.className) { this.templateData.rootContainer.classList.remove(options.className); } if (options.outputClassName) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [], [options.outputClassName]); } }); })); this.viewCell.getCellDecorations().forEach(options => { if (options.className) { this.templateData.rootContainer.classList.add(options.className); } if (options.outputClassName) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [options.outputClassName], []); } }); } </del> private registerMouseListener() { this._register(this.templateData.editor.onMouseDown(e => { // prevent default on right mouse click, otherwise it will trigger unexpected focus changes


this.relayoutCell(); } <del> this.applyDecorations(); </del> this.viewUpdate(); this.layoutCellParts();


this.templateData.container.classList.toggle('cell-editor-focus', this.viewCell.focusMode === CellFocusMode.Editor); } <del> private applyDecorations() { // apply decorations this._register(this.viewCell.onCellDecorationsChanged((e) => { e.added.forEach(options => { if (options.className) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [options.className], []); this.templateData.rootContainer.classList.add(options.className); } }); e.removed.forEach(options => { if (options.className) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [], [options.className]); this.templateData.rootContainer.classList.remove(options.className); } }); })); this.viewCell.getCellDecorations().forEach(options => { if (options.className) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [options.className], []); this.templateData.rootContainer.classList.add(options.className); } }); } </del> override dispose() { this._isDisposed = true;


templateDisposables.add(scopedInstaService.createInstance(CellEditorStatusBar, this.notebookEditor, container, editorPart, undefined)), templateDisposables.add(new CellFocusIndicator(this.notebookEditor, titleToolbar, focusIndicatorTop, focusIndicatorLeft, focusIndicatorRight, focusIndicatorBottom)), templateDisposables.add(new FoldedCellHint(this.notebookEditor, DOM.append(container, $('.notebook-folded-hint')), this._notebookExecutionStateService)), <del> templateDisposables.add(new CellDecorations(rootContainer, decorationContainer)), </del> <ins> templateDisposables.add(new CellDecorations(this.notebookEditor, rootContainer, decorationContainer)), </ins> templateDisposables.add(scopedInstaService.createInstance(CellComments, this.notebookEditor, cellCommentPartContainer)), templateDisposables.add(new CollapsedCellInput(this.notebookEditor, cellInputCollapsedContainer)), templateDisposables.add(new CellFocusPart(container, undefined, this.notebookEditor)),


templateDisposables.add(scopedInstaService.createInstance(CellChatPart, this.notebookEditor, cellChatPart)), templateDisposables.add(scopedInstaService.createInstance(CellEditorStatusBar, this.notebookEditor, container, editorPart, editor)), templateDisposables.add(scopedInstaService.createInstance(CellProgressBar, editorPart, cellInputCollapsedContainer)), <del> templateDisposables.add(new CellDecorations(rootContainer, decorationContainer)), </del> <ins> templateDisposables.add(new CellDecorations(this.notebookEditor, rootContainer, decorationContainer)), </ins> templateDisposables.add(scopedInstaService.createInstance(CellComments, this.notebookEditor, cellCommentPartContainer)), templateDisposables.add(scopedInstaService.createInstance(CellExecutionPart, this.notebookEditor, executionOrderLabel)), templateDisposables.add(scopedInstaService.createInstance(CollapsedCellOutput, this.notebookEditor, cellOutputCollapsedContainer)),


public visible: boolean = false; constructor( <del> readonly id: string, readonly name: string, </del> <ins> readonly id: string, readonly name: string, readonly resource: URI, </ins> protected readonly logger: ILogger, protected readonly proxy: MainThreadOutputServiceShape, readonly extension: IExtensionDescription,


const file = this.extHostFileSystemInfo.extUri.joinPath(outputDir, `${this.namePool++}-${name.replace(/[/:*?"<>|]/g, '')}.log`); const logger = this.loggerService.createLogger(file, { logLevel: 'always', donotRotate: true, donotUseFormatters: true, hidden: true }); const id = await this.proxy.$register(name, file, languageId, extension.identifier.value); <del> return new ExtHostOutputChannel(id, name, logger, this.proxy, extension); </del> <ins> return new ExtHostOutputChannel(id, name, file, logger, this.proxy, extension); </ins> } private async doCreateLogOutputChannel(name: string, logLevel: LogLevel | undefined, extension: IExtensionDescription): Promise<ExtHostLogOutputChannel> {


const file = this.extHostFileSystemInfo.extUri.joinPath(extensionLogDir, `${fileName}.log`); const id = `${extension.identifier.value}.${fileName}`; const logger = this.loggerService.createLogger(file, { id, name, logLevel, extensionId: extension.identifier.value }); <del> return new ExtHostLogOutputChannel(id, name, logger, this.proxy, extension); </del> <ins> return new ExtHostLogOutputChannel(id, name, file, logger, this.proxy, extension); </ins> } private createExtensionLogDirectory(extension: IExtensionDescription): Thenable<URI> {


throw new Error('Channel has been closed'); } }; <ins> const that = this; </ins> return { get name(): string { return name; }, append(value: string): void {


}, dispose(): void { disposed = true; <del> channelPromise.then(channel => channel.dispose()); </del> <ins> channelPromise.then(channel => { that.channels.delete(channel.id); that.loggerService.deregisterLogger(channel.resource); channel.dispose(); }); </ins> } }; }


onDidChangeLogLevel.fire(newLogLevel); } channelPromise.then(channel => { <del> disposables.add(channel); </del> if (channel.logLevel !== logLevel) { setLogLevel(channel.logLevel); } disposables.add(channel.onDidChangeLogLevel(e => setLogLevel(e))); }); <ins> const outputChannel = this.createExtHostOutputChannel(name, channelPromise); </ins> return { <del> ...this.createExtHostOutputChannel(name, channelPromise), </del> <ins> ...outputChannel, </ins> get logLevel() { return logLevel; }, onDidChangeLogLevel: onDidChangeLogLevel.event, trace(value: string, ...args: any[]): void {


}, dispose(): void { disposables.dispose(); <ins> outputChannel.dispose(); </ins> } }; }


public getEditOperations(model: ITextModel, builder: IEditOperationBuilder): void { <ins> const getLanguageId = () => { return model.getLanguageId(); }; const getLanguageIdAtPosition = (lineNumber: number, column: number) => { return model.getLanguageIdAtPosition(lineNumber, column); }; </ins> const modelLineCount = model.getLineCount(); if (this._isMovingDown && this._selection.endLineNumber === modelLineCount) {


const { tabSize, indentSize, insertSpaces } = model.getOptions(); const indentConverter = this.buildIndentConverter(tabSize, indentSize, insertSpaces); <del> const virtualModel: IVirtualModel = { tokenization: { getLineTokens: (lineNumber: number) => { return model.tokenization.getLineTokens(lineNumber); }, getLanguageId: () => { return model.getLanguageId(); }, getLanguageIdAtPosition: (lineNumber: number, column: number) => { return model.getLanguageIdAtPosition(lineNumber, column); }, }, getLineContent: null as unknown as (lineNumber: number) => string, }; </del> if (s.startLineNumber === s.endLineNumber && model.getLineMaxColumn(s.startLineNumber) === 1) { // Current line is empty


insertingText = newIndentation + this.trimStart(movingLineText); } else { // no enter rule matches, let's check indentatin rules then. <del> virtualModel.getLineContent = (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return model.getLineContent(movingLineNumber); } else { return model.getLineContent(lineNumber); } </del> <ins> const virtualModel: IVirtualModel = { tokenization: { getLineTokens: (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return model.tokenization.getLineTokens(movingLineNumber); } else { return model.tokenization.getLineTokens(lineNumber); } }, getLanguageId, getLanguageIdAtPosition, }, getLineContent: (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return model.getLineContent(movingLineNumber); } else { return model.getLineContent(lineNumber); } }, </ins> }; const indentOfMovingLine = getGoodIndentForLine( this._autoIndent,


} } else { // it doesn't match onEnter rules, let's check indentation rules then. <del> virtualModel.getLineContent = (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return insertingText; } else if (lineNumber >= s.startLineNumber + 1 && lineNumber <= s.endLineNumber + 1) { return model.getLineContent(lineNumber - 1); } else { return model.getLineContent(lineNumber); } </del> <ins> const virtualModel: IVirtualModel = { tokenization: { getLineTokens: (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return model.tokenization.getLineTokens(movingLineNumber); } else if (lineNumber >= s.startLineNumber + 1 && lineNumber <= s.endLineNumber + 1) { return model.tokenization.getLineTokens(lineNumber - 1); } else { return model.tokenization.getLineTokens(lineNumber); } }, getLanguageId, getLanguageIdAtPosition, }, getLineContent: (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return insertingText; } else if (lineNumber >= s.startLineNumber + 1 && lineNumber <= s.endLineNumber + 1) { return model.getLineContent(lineNumber - 1); } else { return model.getLineContent(lineNumber); } }, </ins> }; const newIndentatOfMovingBlock = getGoodIndentForLine(


builder.addEditOperation(new Range(s.endLineNumber, model.getLineMaxColumn(s.endLineNumber), s.endLineNumber, model.getLineMaxColumn(s.endLineNumber)), 'n' + movingLineText); if (this.shouldAutoIndent(model, s)) { <del> virtualModel.getLineContent = (lineNumber: number) => { if (lineNumber === movingLineNumber) { return model.getLineContent(s.startLineNumber); } else { return model.getLineContent(lineNumber); } </del> <ins> const virtualModel: IVirtualModel = { tokenization: { getLineTokens: (lineNumber: number) => { if (lineNumber === movingLineNumber) { return model.tokenization.getLineTokens(s.startLineNumber); } else { return model.tokenization.getLineTokens(lineNumber); } }, getLanguageId, getLanguageIdAtPosition, }, getLineContent: (lineNumber: number) => { if (lineNumber === movingLineNumber) { return model.getLineContent(s.startLineNumber); } else { return model.getLineContent(lineNumber); } }, </ins> }; const ret = this.matchEnterRule(model, indentConverter, tabSize, s.startLineNumber, s.startLineNumber - 2);


'enumItemLabels': languagesSorted.map(key => languages[key].name) }, [AccessibilityVoiceSettingId.AutoSynthesize]: { <del> 'type': 'boolean', </del> <ins> 'type': 'string', 'enum': ['on', 'off', 'auto'], 'enumDescriptions': [ localize('accessibility.voice.autoSynthesize.on', "Enable the feature. When a screen reader is enabled, note that this will disable aria updates."), localize('accessibility.voice.autoSynthesize.off', "Disable the feature."), localize('accessibility.voice.autoSynthesize.auto', "When a screen reader is detected, disable the feature. Otherwise, enable the feature.") ], </ins> 'markdownDescription': localize('autoSynthesize', "Whether a textual response should automatically be read out aloud when speech was used as input. For example in a chat session, a response is automatically synthesized when voice was used as chat request."), <del> 'default': this.productService.quality !== 'stable', // TODO@bpasero decide on a default </del> <ins> 'default': this.productService.quality !== 'stable' ? 'auto' : 'off', // TODO@bpasero decide on a default </ins> 'tags': ['accessibility'] } }


Registry.as<IConfigurationMigrationRegistry>(WorkbenchExtensions.ConfigurationMigration) .registerConfigurationMigrations([{ <ins> key: AccessibilityVoiceSettingId.AutoSynthesize, migrateFn: (value: boolean) => { let newValue: string | undefined; if (value === true) { newValue = 'on'; } else if (value === false) { newValue = 'off'; } return [ [AccessibilityVoiceSettingId.AutoSynthesize, { value: newValue }], ]; } }]); Registry.as<IConfigurationMigrationRegistry>(WorkbenchExtensions.ConfigurationMigration) .registerConfigurationMigrations([{ </ins> key: 'accessibility.signals.chatResponsePending', migrateFn: (value, accessor) => { return [


import { IChatResponseViewModel } from 'vs/workbench/contrib/chat/common/chatViewModel'; import { renderStringAsPlaintext } from 'vs/base/browser/markdownRenderer'; import { MarkdownString } from 'vs/base/common/htmlContent'; <ins> import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { AccessibilityVoiceSettingId } from 'vs/workbench/contrib/accessibility/browser/accessibilityConfiguration'; </ins> const CHAT_RESPONSE_PENDING_ALLOWANCE_MS = 4000; export class ChatAccessibilityService extends Disposable implements IChatAccessibilityService {


private _requestId: number = 0; <del> constructor(@IAccessibilitySignalService private readonly _accessibilitySignalService: IAccessibilitySignalService, @IInstantiationService private readonly _instantiationService: IInstantiationService) { </del> <ins> constructor( @IAccessibilitySignalService private readonly _accessibilitySignalService: IAccessibilitySignalService, @IInstantiationService private readonly _instantiationService: IInstantiationService, @IConfigurationService private readonly _configurationService: IConfigurationService ) { </ins> super(); } acceptRequest(): number {


} const errorDetails = isPanelChat && response.errorDetails ? ` ${response.errorDetails.message}` : ''; const plainTextResponse = renderStringAsPlaintext(new MarkdownString(responseContent)); <del> status(plainTextResponse + errorDetails); </del> <ins> if (this._configurationService.getValue(AccessibilityVoiceSettingId.AutoSynthesize) !== 'on') { status(plainTextResponse + errorDetails); } </ins> } }


if (!response) { return; } <del> if ( !this.accessibilityService.isScreenReaderOptimized() && // do not auto synthesize when screen reader is active this.configurationService.getValue<boolean>(AccessibilityVoiceSettingId.AutoSynthesize) === true ) { </del> <ins> const autoSynthesize = this.configurationService.getValue<'on' | 'off' | 'auto'>(AccessibilityVoiceSettingId.AutoSynthesize); if (autoSynthesize === 'on' || autoSynthesize === 'auto' && !this.accessibilityService.isScreenReaderOptimized()) { </ins> let context: IVoiceChatSessionController | 'focused'; if (controller.context === 'inline') { // TODO@bpasero this is ugly, but the lightweight inline chat turns into


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


<del> FROM mcr.microsoft.com/devcontainers/typescript-node:18-bookworm </del> <ins> FROM mcr.microsoft.com/devcontainers/typescript-node:20-bookworm </ins> ADD install-vscode.sh /root/ RUN /root/install-vscode.sh


if (items && items.length > 0) { this.followupsDisposables.add(this.instantiationService.createInstance<typeof ChatFollowups<IChatFollowup>, ChatFollowups<IChatFollowup>>(ChatFollowups, this.followupsContainer, items, this.location, undefined, followup => this._onDidAcceptFollowup.fire({ followup, response }))); } <ins> this._onDidChangeHeight.fire(); </ins> } get contentHeight(): number {


this._store.add(this._widget); this._widget.render(this._inputContainer); this._widget.setModel(this._defaultChatModel, {}); <del> this._store.add(this._widget.inputEditor.onDidContentSizeChange(() => _editor.layoutContentWidget(this))); </del> <ins> this._store.add(this._widget.onDidChangeContentHeight(() => _editor.layoutContentWidget(this))); </ins> this._domNode.tabIndex = -1; this._domNode.className = 'inline-chat-content-widget interactive-session';


disturl "https://electronjs.org/headers" target "29.4.0" <del> ms_build_id "9593362" </del> <ins> ms_build_id "9728852" </ins> runtime "electron" build_from_source "true"


{ "name": "code-oss-dev", "version": "1.91.0", <del> "distro": "170beceb9849568b8f7159757bc3fc3964af1986", </del> <ins> "distro": "361fc45f5932b161db29080d5b19bc5afb9baae6", </ins> "author": { "name": "Microsoft Corporation" },


wait_for_async_execs <del> exec "$@" "--no-sandbox" </del> <ins> exec "$@" </ins>


apps: @@NAME@@: <del> command: electron-launch $SNAP/usr/share/@@NAME@@/bin/@@NAME@@ </del> <ins> command: electron-launch $SNAP/usr/share/@@NAME@@/bin/@@NAME@@ --no-sandbox </ins> common-id: @@NAME@@.desktop url-handler: <del> command: electron-launch $SNAP/usr/share/@@NAME@@/bin/@@NAME@@ --open-url </del> <ins> command: electron-launch $SNAP/usr/share/@@NAME@@/bin/@@NAME@@ --open-url --no-sandbox </ins>


} set statusBarCommands(statusBarCommands: vscode.Command[] | undefined) { <del> this.logService.info('ExtHostSourceControl#statusBarCommands', (statusBarCommands ?? []).map(c => c.command).join(', ')); </del> <ins> this.logService.trace('ExtHostSourceControl#statusBarCommands', (statusBarCommands ?? []).map(c => c.command).join(', ')); </ins> if (this._statusBarCommands && statusBarCommands && commandListEquals(this._statusBarCommands, statusBarCommands)) { <del> this.logService.info('ExtHostSourceControl#statusBarCommands are equal'); </del> <ins> this.logService.trace('ExtHostSourceControl#statusBarCommands are equal'); </ins> return; }


const visibleRanges = editor.getVisibleRanges(); if (visibleRanges.length > 0) { visiblePosition = visibleRanges[0].getStartPosition(); <ins> const cursorPos = editor.getPosition(); if (cursorPos) { const isVisible = visibleRanges.some(range => range.containsPosition(cursorPos)); if (isVisible) { // Keep cursor pos fixed if it is visible visiblePosition = cursorPos; } } </ins> const visiblePositionScrollTop = editor.getTopForPosition(visiblePosition.lineNumber, visiblePosition.column); visiblePositionScrollDelta = editor.getScrollTop() - visiblePositionScrollTop; }


keybinding: { weight: KeybindingWeight.WorkbenchContrib, primary: KeyMod.CtrlCmd | KeyCode.Escape, <ins> win: { primary: KeyMod.Alt | KeyCode.Backspace }, </ins> } }); }


padding-right: 4px; } <ins> .monaco-hover .hover-row.status-bar .actions .action-container a { color: var(--vscode-textLink-foreground); text-decoration: var(--text-link-decoration); } </ins> .monaco-hover .markdown-hover .hover-contents .codicon { color: inherit; font-size: inherit;


.monaco-workbench .hover-language-status > .element .right .monaco-link { margin: auto 0; white-space: nowrap; <ins> text-decoration: var(--text-link-decoration); </ins> } .monaco-workbench .hover-language-status > .element .right .monaco-action-bar:not(:first-child) {


this._viewsService.openView(Markers.MARKERS_VIEW_ID); } else if (task.command.presentation && (task.command.presentation.focus || task.command.presentation.reveal === RevealKind.Always)) { this._terminalService.setActiveInstance(terminal); <del> await this._terminalService.revealActiveTerminal(); </del> <ins> await this._terminalService.revealTerminal(terminal); </ins> if (task.command.presentation.focus) { <del> this._terminalService.focusActiveInstance(); </del> <ins> this._terminalService.focusInstance(terminal); </ins> } } this._activeTasks[task.getMapKey()].terminal = terminal;


getReconnectedTerminals(reconnectionOwner: string): ITerminalInstance[] | undefined; getActiveOrCreateInstance(options?: { acceptsInput?: boolean }): Promise<ITerminalInstance>; <ins> revealTerminal(source: ITerminalInstance, preserveFocus?: boolean): Promise<void>; </ins> revealActiveTerminal(preserveFocus?: boolean): Promise<void>; moveToEditor(source: ITerminalInstance, group?: GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE): void; moveIntoNewEditor(source: ITerminalInstance): void;


setActiveInstance(instance: ITerminalInstance): void; /** <ins> * Reveal and focus the instance, regardless of its location. */ focusInstance(instance: ITerminalInstance): void; /** </ins> * Reveal and focus the active instance, regardless of its location. */ focusActiveInstance(): Promise<void>;


this._onDidChangeActiveInstance.fire(this.activeInstance); } <ins> async focusInstance(instance: ITerminalInstance): Promise<void> { return instance.focusWhenReady(true); } </ins> async focusActiveInstance(): Promise<void> { return this.activeInstance?.focusWhenReady(true); }


pane?.terminalTabbedView?.focusHover(); } <ins> async focusInstance(_: ITerminalInstance): Promise<void> { return this.showPanel(true); } </ins> async focusActiveInstance(): Promise<void> { return this.showPanel(true); }


} } <ins> async focusInstance(instance: ITerminalInstance): Promise<void> { if (instance.target === TerminalLocation.Editor) { return this._terminalEditorService.focusInstance(instance); } return this._terminalGroupService.focusInstance(instance); } </ins> async focusActiveInstance(): Promise<void> { if (!this._activeInstance) { return; } <del> if (this._activeInstance.target === TerminalLocation.Editor) { return this._terminalEditorService.focusActiveInstance(); } return this._terminalGroupService.focusActiveInstance(); </del> <ins> return this.focusInstance(this._activeInstance); </ins> } async createContributedTerminalProfile(extensionIdentifier: string, id: string, options: ICreateContributedTerminalProfileOptions): Promise<void> {


return instance; } <ins> async revealTerminal(source: ITerminalInstance, preserveFocus?: boolean): Promise<void> { if (source.target === TerminalLocation.Editor) { await this._terminalEditorService.revealActiveEditor(preserveFocus); } else { await this._terminalGroupService.showPanel(); } } </ins> async revealActiveTerminal(preserveFocus?: boolean): Promise<void> { const instance = this.activeInstance; if (!instance) { return; } <del> if (instance.target === TerminalLocation.Editor) { await this._terminalEditorService.revealActiveEditor(preserveFocus); } else { await this._terminalGroupService.showPanel(); } </del> <ins> await this.revealTerminal(instance, preserveFocus); </ins> } setEditable(instance: ITerminalInstance, data?: IEditableData | null): void {


getInputFromResource(resource: URI): TerminalEditorInput { throw new Error('Method not implemented.'); } setActiveInstance(instance: ITerminalInstance): void { throw new Error('Method not implemented.'); } focusActiveInstance(): Promise<void> { throw new Error('Method not implemented.'); } <ins> focusInstance(instance: ITerminalInstance): void { throw new Error('Method not implemented.'); } </ins> getInstanceFromResource(resource: URI | undefined): ITerminalInstance | undefined { throw new Error('Method not implemented.'); } focusFindWidget(): void { throw new Error('Method not implemented.'); } hideFindWidget(): void { throw new Error('Method not implemented.'); }


focusHover(): void { throw new Error('Method not implemented.'); } setActiveInstance(instance: ITerminalInstance): void { throw new Error('Method not implemented.'); } focusActiveInstance(): Promise<void> { throw new Error('Method not implemented.'); } <ins> focusInstance(instance: ITerminalInstance): void { throw new Error('Method not implemented.'); } </ins> getInstanceFromResource(resource: URI | undefined): ITerminalInstance | undefined { throw new Error('Method not implemented.'); } focusFindWidget(): void { throw new Error('Method not implemented.'); } hideFindWidget(): void { throw new Error('Method not implemented.'); }


// no parsed args, try handle active editor const editor = getEditorFromArgsOrActivePane(accessor); if (editor) { <ins> const selectedCellRange: ICellRange[] = editor.getSelections().length === 0 ? [editor.getFocus()] : editor.getSelections(); </ins> telemetryService.publicLog2<WorkbenchActionExecutedEvent, WorkbenchActionExecutedClassification>('workbenchActionExecuted', { id: this.desc.id, from: from }); return this.runWithContext(accessor, { ui: false, notebookEditor: editor, <del> selectedCells: cellRangeToViewCells(editor, editor.getSelections()) </del> <ins> selectedCells: cellRangeToViewCells(editor, selectedCellRange) </ins> }); } }


keybinding: { when: ContextKeyExpr.and( NOTEBOOK_EDITOR_FOCUSED, <del> NOTEBOOK_CELL_LIST_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey), </del> NOTEBOOK_EDITOR_EDITABLE, <del> NOTEBOOK_CELL_EDITABLE </del> <ins> ContextKeyExpr.not(InputFocusedContextKey), </ins> ), primary: KeyMod.CtrlCmd | KeyCode.Slash, weight: KeybindingWeight.WorkbenchContrib


} }); selectedCellEditors.forEach(editor => { if (!editor.hasModel()) { return;


const modelOptions = model.getOptions(); const commentsOptions = editor.getOption(EditorOption.comments); <ins> const selection = editor.getSelection(); </ins> commands.push(new LineCommentCommand( languageConfigurationService, new Selection(1, 1, model.getLineCount(), model.getLineMaxColumn(model.getLineCount())),


editor.pushUndoStop(); editor.executeCommands(COMMENT_SELECTED_CELLS_ID, commands); editor.pushUndoStop(); <ins> editor.setSelection(selection); </ins> }); }


} registerThemingParticipant((theme, collector) => { <ins> const scope = '.monaco-editor .glyph-margin-widgets, .monaco-workbench .debug-breakpoints, .monaco-workbench .disassembly-view'; </ins> const debugIconBreakpointColor = theme.getColor(debugIconBreakpointForeground); if (debugIconBreakpointColor) { <del> collector.addRule(` ${icons.allBreakpoints.map(b => `.monaco-workbench ${ThemeIcon.asCSSSelector(b.regular)}`).join(',n		')}, .monaco-workbench ${ThemeIcon.asCSSSelector(icons.debugBreakpointUnsupported)}, .monaco-workbench ${ThemeIcon.asCSSSelector(icons.debugBreakpointHint)}:not([class*='codicon-debug-breakpoint']):not([class*='codicon-debug-stackframe']), .monaco-workbench ${ThemeIcon.asCSSSelector(icons.breakpoint.regular)}${ThemeIcon.asCSSSelector(icons.debugStackframeFocused)}::after, .monaco-workbench ${ThemeIcon.asCSSSelector(icons.breakpoint.regular)}${ThemeIcon.asCSSSelector(icons.debugStackframe)}::after { color: ${debugIconBreakpointColor} !important; } `); </del> <ins> collector.addRule(`${scope} { ${icons.allBreakpoints.map(b => `${ThemeIcon.asCSSSelector(b.regular)}`).join(',n		')}, ${ThemeIcon.asCSSSelector(icons.debugBreakpointUnsupported)}, ${ThemeIcon.asCSSSelector(icons.debugBreakpointHint)}:not([class*='codicon-debug-breakpoint']):not([class*='codicon-debug-stackframe']), ${ThemeIcon.asCSSSelector(icons.breakpoint.regular)}${ThemeIcon.asCSSSelector(icons.debugStackframeFocused)}::after, ${ThemeIcon.asCSSSelector(icons.breakpoint.regular)}${ThemeIcon.asCSSSelector(icons.debugStackframe)}::after { color: ${debugIconBreakpointColor} !important; } }`); </ins> <del> collector.addRule(` .monaco-workbench ${ThemeIcon.asCSSSelector(icons.breakpoint.pending)} { color: ${debugIconBreakpointColor} !important; font-size: 12px !important; } `); </del> <ins> collector.addRule(`${scope} { ${ThemeIcon.asCSSSelector(icons.breakpoint.pending)} { color: ${debugIconBreakpointColor} !important; font-size: 12px !important; } }`); </ins> } const debugIconBreakpointDisabledColor = theme.getColor(debugIconBreakpointDisabledForeground); if (debugIconBreakpointDisabledColor) { <del> collector.addRule(` ${icons.allBreakpoints.map(b => `.monaco-workbench ${ThemeIcon.asCSSSelector(b.disabled)}`).join(',n		')} { color: ${debugIconBreakpointDisabledColor}; } `); </del> <ins> collector.addRule(`${scope} { ${icons.allBreakpoints.map(b => ThemeIcon.asCSSSelector(b.disabled)).join(',n		')} { color: ${debugIconBreakpointDisabledColor}; } }`); </ins> } const debugIconBreakpointUnverifiedColor = theme.getColor(debugIconBreakpointUnverifiedForeground); if (debugIconBreakpointUnverifiedColor) { <del> collector.addRule(` ${icons.allBreakpoints.map(b => `.monaco-workbench ${ThemeIcon.asCSSSelector(b.unverified)}`).join(',n		')} { color: ${debugIconBreakpointUnverifiedColor}; } `); </del> <ins> collector.addRule(`${scope} { ${icons.allBreakpoints.map(b => ThemeIcon.asCSSSelector(b.unverified)).join(',n		')} { color: ${debugIconBreakpointUnverifiedColor}; } }`); </ins> } const debugIconBreakpointCurrentStackframeForegroundColor = theme.getColor(debugIconBreakpointCurrentStackframeForeground); if (debugIconBreakpointCurrentStackframeForegroundColor) { collector.addRule(` <del> .monaco-workbench ${ThemeIcon.asCSSSelector(icons.debugStackframe)}, </del> .monaco-editor .debug-top-stack-frame-column { color: ${debugIconBreakpointCurrentStackframeForegroundColor} !important; } <ins> ${scope} { ${ThemeIcon.asCSSSelector(icons.debugStackframe)} { color: ${debugIconBreakpointCurrentStackframeForegroundColor} !important; } } </ins> `); } const debugIconBreakpointStackframeFocusedColor = theme.getColor(debugIconBreakpointStackframeForeground); if (debugIconBreakpointStackframeFocusedColor) { <del> collector.addRule(` .monaco-workbench ${ThemeIcon.asCSSSelector(icons.debugStackframeFocused)} { color: ${debugIconBreakpointStackframeFocusedColor} !important; } `); </del> <ins> collector.addRule(`${scope} { ${ThemeIcon.asCSSSelector(icons.debugStackframeFocused)} { color: ${debugIconBreakpointStackframeFocusedColor} !important; } }`); </ins> } });


} )) as WorkbenchTable<IDisassembledInstructionEntry>; <ins> this._disassembledInstructions.domNode.classList.add('disassembly-view'); </ins> if (this.focusedInstructionReference) { this.reloadDisassembly(this.focusedInstructionReference, 0); }


// align from the bottom so that it lines up with instruction when source code is present. container.style.alignSelf = 'flex-end'; <del> const icon = append(container, $('.disassembly-view')); icon.classList.add('codicon'); </del> <ins> const icon = append(container, $('.codicon')); </ins> icon.style.display = 'flex'; icon.style.alignItems = 'center'; icon.style.justifyContent = 'center';


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


} override dispose() { <ins> // The editor isn't disposed yet, it can be re-used. // However the model can be disposed before the editor & that causes issues. if (this._editor) { this._editor.setModel(null); } </ins> if (this._editor && this._editorViewStateChanged) { this.cell.saveSpirceEditorViewState(this._editor.saveViewState()); }


return $('tr', undefined, ...row.map(rowData => { if (typeof rowData === 'string') { <del> return $('td', undefined, rowData); </del> <ins> return $('td', undefined, $('p', undefined, rowData)); </ins> } const data = Array.isArray(rowData) ? rowData : [rowData]; return $('td', undefined, ...data.map(item => {


alias: { './node/authServer': path.resolve(__dirname, 'src/browser/authServer'), './node/buffer': path.resolve(__dirname, 'src/browser/buffer'), <ins> './node/fetch': path.resolve(__dirname, 'src/browser/fetch'), </ins> './node/authProvider': path.resolve(__dirname, 'src/browser/authProvider'), } }


import { BetterTokenStorage, IDidChangeInOtherWindowEvent } from './betterSecretStorage'; import { LoopbackAuthServer } from './node/authServer'; import { base64Decode } from './node/buffer'; <ins> import fetch from './node/fetch'; </ins> import { UriEventHandler } from './UriEventHandler'; import TelemetryReporter from '@vscode/extension-telemetry'; import { Environment } from '@azure/ms-rest-azure-env';


let result; let errorMessage: string | undefined; try { <del> result = await fetch(endpoint, { </del> <ins> result = await fetch(endpoint.toString(), { </ins> method: 'POST', headers: { <del> 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': postData.length.toString() </del> <ins> 'Content-Type': 'application/x-www-form-urlencoded' </ins> }, body: postData });


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ export default fetch; </ins>


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ let _fetch: typeof fetch; try { _fetch = require('electron').net.fetch; } catch { _fetch = fetch; } export default _fetch; </ins>


this._versionId = this._textModel.getVersionId(); this._alternativeId = this._textModel.getAlternativeVersionId(); } <ins> this._textBufferHash = null; </ins> this._onDidChangeContent.fire('content'); }));


import { $, append } from 'vs/base/browser/dom'; import { IHoverOptions, IManagedHover, IManagedHoverTooltipMarkdownString } from 'vs/base/browser/ui/hover/hover'; import { IHoverDelegate } from 'vs/base/browser/ui/hover/hoverDelegate'; <del> import { createInstantHoverDelegate, getDefaultHoverDelegate } from 'vs/base/browser/ui/hover/hoverDelegateFactory'; </del> <ins> import { getDefaultHoverDelegate } from 'vs/base/browser/ui/hover/hoverDelegateFactory'; </ins> import { IconLabel } from 'vs/base/browser/ui/iconLabel/iconLabel'; import { IIdentityProvider, IKeyboardNavigationLabelProvider, IListVirtualDelegate } from 'vs/base/browser/ui/list/list'; import { LabelFuzzyScore } from 'vs/base/browser/ui/tree/abstractTree';


templateData.labelContainer.textContent = ''; if (historyItem.labels) { <del> const instantHoverDelegate = createInstantHoverDelegate(); templateData.elementDisposables.add(instantHoverDelegate); </del> // Get lits of labels to render (current, remote, base) const labels = this.getLabels(node.element.repository);


if (label.icon && ThemeIcon.isThemeIcon(label.icon) && labels.includes(label.title)) { const icon = append(templateData.labelContainer, $('div.label')); icon.classList.add(...ThemeIcon.asClassNameArray(label.icon)); <del> const hover = this.hoverService.setupManagedHover(instantHoverDelegate, icon, label.title); templateData.elementDisposables.add(hover); </del> } } }


const editorGroupService = accessor.get(IEditorGroupsService); const newOrientation = (editorGroupService.orientation === GroupOrientation.VERTICAL) ? GroupOrientation.HORIZONTAL : GroupOrientation.VERTICAL; editorGroupService.setGroupOrientation(newOrientation); <ins> editorGroupService.activeGroup.focus(); </ins> } });


this._compositionRangeWithinEditor = newCompositionRangeWithinEditor; } this._emitTypeEvent(viewController, e); <del> // TODO @aiday-mar calling write screen reader content so that the document selection is immediately set // remove the following when electron will be upgraded this._screenReaderSupport.writeScreenReaderContent(); </del> })); this._register(editContextAddDisposableListener(this._editContext, 'compositionstart', (e) => { const position = this._context.viewModel.getPrimaryCursorState().modelState.position;


} private _getScreenReaderContentState(): ScreenReaderContentState | undefined { <del> // Make the screen reader content always be visible because of the bug and also set the selection // TODO @aiday-mar Ultimately uncomment this code when Electron will be upgraded // if (this._accessibilitySupport === AccessibilitySupport.Disabled) { // 	return; // } const accessibilityPageSize = this._accessibilitySupport === AccessibilitySupport.Disabled ? 1 : this._accessibilityPageSize; </del> <ins> if (this._accessibilitySupport === AccessibilitySupport.Disabled) { return; } </ins> const simpleModel: ISimpleModel = { getLineCount: (): number => { return this._context.viewModel.getLineCount();


return this._context.viewModel.modifyPosition(position, offset); } }; <del> return PagedScreenReaderStrategy.fromEditorSelection(simpleModel, this._primarySelection, accessibilityPageSize, this._accessibilitySupport === AccessibilitySupport.Unknown); </del> <ins> return PagedScreenReaderStrategy.fromEditorSelection(simpleModel, this._primarySelection, this._accessibilityPageSize, this._accessibilitySupport === AccessibilitySupport.Unknown); </ins> } private _setSelectionOfScreenReaderContent(selectionOffsetStart: number, selectionOffsetEnd: number): void {


*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> import { getActiveWindow } from '../../../../../base/browser/dom.js'; </del> <ins> import { getActiveWindow, isHTMLElement } from '../../../../../base/browser/dom.js'; </ins> import { FastDomNode } from '../../../../../base/browser/fastDomNode.js'; import { AccessibilitySupport } from '../../../../../platform/accessibility/common/accessibility.js'; import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.js';


if (!textContent) { return; } <ins> const focusedElement = getActiveWindow().document.activeElement; </ins> const range = new globalThis.Range(); range.setStart(textContent, selectionOffsetStart); range.setEnd(textContent, selectionOffsetEnd); activeDocumentSelection.removeAllRanges(); activeDocumentSelection.addRange(range); <ins> if (isHTMLElement(focusedElement)) { focusedElement.focus(); } </ins> } }


} }; <ins> for (const breakpoint of this.model.getBreakpoints({ triggeredOnly: true })) { breakpoint.setSessionDidTrigger(session.getId(), false); } </ins> // For debug sessions spawned by test runs, cancel the test run and stop // the session, then start the test run again; tests have no notion of restarts. if (session.correlatedTestRun) {


readonly pending: boolean; /** Marks that a session did trigger the breakpoint. */ <del> setSessionDidTrigger(sessionId: string): void; </del> <ins> setSessionDidTrigger(sessionId: string, didTrigger?: boolean): void; </ins> /** Gets whether the `triggeredBy` condition has been met in the given sesison ID. */ getSessionDidTrigger(sessionId: string): boolean;


return `${resources.basenameOrAuthority(this.uri)} ${this.lineNumber}`; } <del> public setSessionDidTrigger(sessionId: string): void { this.sessionsDidTrigger ??= new Set(); this.sessionsDidTrigger.add(sessionId); </del> <ins> public setSessionDidTrigger(sessionId: string, didTrigger = true): void { if (didTrigger) { this.sessionsDidTrigger ??= new Set(); this.sessionsDidTrigger.add(sessionId); } else { this.sessionsDidTrigger?.delete(sessionId); } </ins> } public getSessionDidTrigger(sessionId: string): boolean {


}, 0); }; <ins> const isEditableElement = (element: Element) => { return element.tagName.toLowerCase() === 'input' || element.tagName.toLowerCase() === 'textarea' || 'editContext' in element; }; </ins> // check if an input element is focused within the output element const checkOutputInputFocus = (e: FocusEvent) => { lastFocusedOutput = getOutputContainer(e);


JSON.parse(decodeURIComponent("${encodeURIComponent(JSON.stringify(ctx))}")) )n//# sourceURL=notebookWebviewPreloads.jsn`; } <del> export function isEditableElement(element: Element): boolean { return element.tagName.toLowerCase() === 'input' || element.tagName.toLowerCase() === 'textarea' || 'editContext' in element; } </del>


viewController.emitKeyDown(standardKeyboardEvent); })); this._register(addDisposableListener(this.domNode.domNode, 'beforeinput', async (e) => { <del> if (e.inputType === 'insertParagraph') { </del> <ins> if (e.inputType === 'insertParagraph' || e.inputType === 'insertLineBreak') { </ins> this._onType(viewController, { text: 'n', replacePrevCharCnt: 0, replaceNextCharCnt: 0, positionDelta: 0 }); } }));