private readonly _localStore = this._register(new DisposableStore()); private _cellStateListeners: IDisposable[] = []; <del> private _logging: boolean = false; </del> <ins> private _enabled: boolean = false; private _cellStatusItems: string[] = []; </ins> constructor(private readonly _notebookEditor: INotebookEditor) { super(); this._register(this._notebookEditor.onDidChangeModel(() => { <del> this._localStore.clear(); this._cellStateListeners.forEach(listener => listener.dispose()); if (!this._notebookEditor.hasModel()) { return; } this._updateListener(); </del> <ins> this._update(); </ins> })); <del> this._updateListener(); </del> <ins> this._update(); </ins> } <del> toggleLogging(): void { this._logging = !this._logging; </del> <ins> toggle(): void { this._enabled = !this._enabled; this._update(); } private _update() { this._localStore.clear(); this._cellStateListeners.forEach(listener => listener.dispose()); if (!this._notebookEditor.hasModel()) { return; } this._updateListener(); </ins> } private _log(cell: ICellViewModel, e: any) { <del> if (this._logging) { </del> <ins> if (this._enabled) { </ins> const oldHeight = (this._notebookEditor as NotebookEditorWidget).getViewHeight(cell); console.log(`cell#${cell.handle}`, e, `${oldHeight} -> ${cell.layoutInfo.totalHeight}`); }


resolved "https://registry.yarnpkg.com/@vscode/windows-registry/-/windows-registry-1.1.0.tgz#03dace7c29c46f658588b9885b9580e453ad21f9" integrity sha512-5AZzuWJpGscyiMOed0IuyEwt6iKmV5Us7zuwCDCFYMIq7tsvooO9BUiciywsvuthGz6UG4LSpeDeCxvgMVhnIw== <del> "@xterm/addon-canvas@0.6.0-beta.19": version "0.6.0-beta.19" resolved "https://registry.yarnpkg.com/@xterm/addon-canvas/-/addon-canvas-0.6.0-beta.19.tgz#5f8896b884d2a558a28eb197f7f4766ac37d33a0" integrity sha512-i+26DqYgI/PZViCiEK4Vu8c4Fi5J0i+TwnFfBDLcumHH07Al1uRd5BRaVg/i93vk6bRyEIOiOiIToXSf37ov/w== "@xterm/addon-image@0.7.0-beta.17": version "0.7.0-beta.17" resolved "https://registry.yarnpkg.com/@xterm/addon-image/-/addon-image-0.7.0-beta.17.tgz#bc3d6f09619ef1f3b68c7009d29ee14003a26b30" integrity sha512-nnHVoYVoh+CpT4FQN/ALKesr96YvdVNUzQRQo4aAARUKst5DFaHQX9Yn/qLDN5s0WCqI3bgIEo8UAakfHITumA== "@xterm/addon-search@0.14.0-beta.19": version "0.14.0-beta.19" resolved "https://registry.yarnpkg.com/@xterm/addon-search/-/addon-search-0.14.0-beta.19.tgz#2bc13378765f0d5e72d9bcb7887e23eee31de7eb" integrity sha512-Y1pPdtdZj0xRQ/Is4jdO0dyZe+uM6AhWi3v2U4sdJmhz2mxVe/HAKBHkx6tyfMtX9ge/9ZYajd/Sy8rkjIFdmQ== "@xterm/addon-serialize@0.12.0-beta.19": version "0.12.0-beta.19" resolved "https://registry.yarnpkg.com/@xterm/addon-serialize/-/addon-serialize-0.12.0-beta.19.tgz#465a9525a420b8f0d12eed419d6e051f9a887814" integrity sha512-3v6a4/4gxAwoyJsBp6vJBofymgTH8paSHl8K2uQfFuLosOavNyCtrNPiNne7tpppK6t8zCDJ/mVrXNptz4Mlsg== "@xterm/addon-unicode11@0.7.0-beta.19": version "0.7.0-beta.19" resolved "https://registry.yarnpkg.com/@xterm/addon-unicode11/-/addon-unicode11-0.7.0-beta.19.tgz#0e81775f84346a97c657fb4cd7702de1cfe4b83f" integrity sha512-U5O+JLklO4qtptWAWUw14QRWdalLl0bFAQxLKuTtDmusgfn33pNDRD6RH3R+IHhO2e6svAwrw27OcCEcdn0AJQ== "@xterm/addon-webgl@0.17.0-beta.19": version "0.17.0-beta.19" resolved "https://registry.yarnpkg.com/@xterm/addon-webgl/-/addon-webgl-0.17.0-beta.19.tgz#fefe44c20b4d4d070363e03ae33087505a88807e" integrity sha512-L59l9Cd4KTMCwnw2HPi/cUgH4iL5dK7VERK/wSTWEGYMOi3WGTmXqsg8ftfR2jFC9P33eqYNVJDmbr+pF0XsDg== "@xterm/headless@5.4.0-beta.19": version "5.4.0-beta.19" resolved "https://registry.yarnpkg.com/@xterm/headless/-/headless-5.4.0-beta.19.tgz#e84a7cebda581273032f82fc8c53941204bc7f93" integrity sha512-y7Ne2G/Tgn6bHr14eBHqcq5gGFFCHKGBzmXTExT1Z4Fb6ofPACPWAo60S5B6uh49W4Ts13gQYZ5C0XEvHud0Eg== "@xterm/xterm@5.4.0-beta.19": version "5.4.0-beta.19" resolved "https://registry.yarnpkg.com/@xterm/xterm/-/xterm-5.4.0-beta.19.tgz#5c9c5cacd0cf2a0719086ce03ab035480b1cfd96" integrity sha512-Rx/Y/y3YGjpiW6IUq8UlE6qrTYuUlEfpVg/BS6kIPr8/cUOchE1fsKWCMxz/u2bIyQyEovRi892iYcQJ4scstw== </del> <ins> "@xterm/addon-canvas@0.6.0-beta.20": version "0.6.0-beta.20" resolved "https://registry.yarnpkg.com/@xterm/addon-canvas/-/addon-canvas-0.6.0-beta.20.tgz#078dddef70caf880b2cb121fdda37d301fc13156" integrity sha512-tHhsuqElE7LNiDJPbZzgVpmbcG2Dk6i2vh1EI+DzSByUWScDqLoeJbVPE5Xd2UW2garo24lxErpnIAlsytcA3A== "@xterm/addon-image@0.7.0-beta.18": version "0.7.0-beta.18" resolved "https://registry.yarnpkg.com/@xterm/addon-image/-/addon-image-0.7.0-beta.18.tgz#588ea2d0841cff48c63bde1bfcdf56e9494dc6af" integrity sha512-+HQ+IBmHPelzjRJ5zO3XkjbeQNr2Zrf5wAlbPhy4EGSD0mDCqHJSfzZ8wKrhx7t8qpfiA8eTpWu/M76WsEnlnA== "@xterm/addon-search@0.14.0-beta.20": version "0.14.0-beta.20" resolved "https://registry.yarnpkg.com/@xterm/addon-search/-/addon-search-0.14.0-beta.20.tgz#cac366b1be1eb02cf9fe9537933f26f227d030c8" integrity sha512-1LOL/OzWSrCBpndiBeeE2S1rxtKKgU1ucYFSG3P68W0J4VQz/Ksci1BgDKsgspj9jzpsGhdql3zwa5WEM7n4Pg== "@xterm/addon-serialize@0.12.0-beta.20": version "0.12.0-beta.20" resolved "https://registry.yarnpkg.com/@xterm/addon-serialize/-/addon-serialize-0.12.0-beta.20.tgz#5fe126194ff4dc466b92a0946e081e039a14ad21" integrity sha512-GdRCQDjLyVNBxCFnhfCWsMmuqv2PryUkOaNl4z5MqB5lBUkiEnRNY0u/s5f34+2zrijp3h0O/f9JDLW4gSUQgw== "@xterm/addon-unicode11@0.7.0-beta.20": version "0.7.0-beta.20" resolved "https://registry.yarnpkg.com/@xterm/addon-unicode11/-/addon-unicode11-0.7.0-beta.20.tgz#5d3c97320898dd6766f2dc127deb4f071c8698c2" integrity sha512-4/uwJ6lV/xJplT7hJc7sO4Im4XNvEXHnUEFIs03FFp8ZUfu3U6wcBk6/GoKMwJKJtGVNxotiD6ZzJ5v8IBH6nA== "@xterm/addon-webgl@0.17.0-beta.20": version "0.17.0-beta.20" resolved "https://registry.yarnpkg.com/@xterm/addon-webgl/-/addon-webgl-0.17.0-beta.20.tgz#443845ac5ac755cf762b105ed237b30426b07137" integrity sha512-iqvXNSTfKIcO9FBraNwdO/ixPrTHok8CBN/wjlnGLv0ZMc4zLAiKE8+PHyg9ZY38QJfS+4Ouo8KsuZwoOYfnNA== "@xterm/headless@5.4.0-beta.20": version "5.4.0-beta.20" resolved "https://registry.yarnpkg.com/@xterm/headless/-/headless-5.4.0-beta.20.tgz#af26d3d0e2cdd615ccfac4a8660181fee19898fd" integrity sha512-H/as1d67J43/CB8xt1Yg/eJMbq1yopwG1bDBKdsf2ro8A1PmJFXNzaDB+wSgoH42fCusSpLJvXtUvDLtqfvBTg== "@xterm/xterm@5.4.0-beta.20": version "5.4.0-beta.20" resolved "https://registry.yarnpkg.com/@xterm/xterm/-/xterm-5.4.0-beta.20.tgz#28bbbbc73eceb6ef3e1e095de195cf849d0cbfb6" integrity sha512-nkY91qBy5pe1HlW9LOoLcyG6v4teEsliEtUVshAO42NrJDaPniSn28O5m5832UjZOdjLCY58QlcBkZUquODGrQ== </ins> agent-base@^7.0.1, agent-base@^7.0.2, agent-base@^7.1.0: version "7.1.0"


element.hidden = element.item ? !element.item.alwaysShow : true; } <ins> // Ensure separators are filtered out first before deciding if we need to bring them back if (element.item) { element.separator = undefined; } else if (element.separator) { element.hidden = true; } </ins> // we can show the separator unless the list gets sorted by match if (!this.sortByLabel) { const previous = element.index && this.inputElements[element.index - 1];


<ins> [Desktop Entry] Name=@@NAME_LONG@@ - URL Handler Comment=Code Editing. Redefined. GenericName=Text Editor Exec=/usr/share/@@NAME@@/@@NAME@@ --open-url %U Icon=@@ICON@@ Type=Application NoDisplay=true StartupNotify=true StartupWMClass=@@NAME_SHORT@@ Categories=Utility;TextEditor;Development;IDE; MimeType=x-scheme-handler/vscode Keywords=vscode; </ins>


import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility'; import { CellEditState, IInsetRenderOutput, INotebookEditor, INotebookEditorContribution, INotebookEditorDelegate, RenderOutputType } from 'vs/workbench/contrib/notebook/browser/notebookBrowser'; import { registerNotebookContribution } from 'vs/workbench/contrib/notebook/browser/notebookEditorExtensions'; <del> import { CodeCellViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel'; </del> <ins> import { CodeCellViewModel, outputDisplayLimit } from 'vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel'; </ins> import { CellKind } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { cellRangesToIndexes } from 'vs/workbench/contrib/notebook/common/notebookRange'; import { INotebookService } from 'vs/workbench/contrib/notebook/common/notebookService';


"tas-client-umd": "0.1.6", "vscode-oniguruma": "1.6.1", "vscode-textmate": "7.0.1", <del> "xterm": "4.19.0-beta.60", "xterm-addon-search": "0.9.0-beta.39", </del> <ins> "xterm": "4.19.0-beta.67", "xterm-addon-search": "0.9.0-beta.41", </ins> "xterm-addon-unicode11": "0.4.0-beta.3", <del> "xterm-addon-webgl": "0.12.0-beta.41" </del> <ins> "xterm-addon-webgl": "0.12.0-beta.43" </ins> } }


<meta charset="UTF-8"> <meta http-equiv="Content-Security-Policy" <del> content="default-src 'none'; script-src 'sha256-RaCvj6SRgHm+2C3LKzSAamDwa3Bp4u4iQ1Y2Sm+97tE=' 'self'; frame-src 'self'; style-src 'unsafe-inline';"> </del> <ins> content="default-src 'none'; script-src 'sha256-f/XuzcTyXb1X6po1otWlqfEUBjHOsprrTOZknXfbS9I=' 'self'; frame-src 'self'; style-src 'unsafe-inline';"> </ins> <!-- Disable pinch zooming --> <meta name="viewport"


return newLinkProvider; } <del> protected get _localLinkRegex(): RegExp { if (!this._processManager) { throw new Error('Process manager is required'); } const baseLocalLinkClause = this._processManager.os === OperatingSystem.Windows ? winLocalLinkClause : unixLocalLinkClause; // Append line and column number regex return new RegExp(`${baseLocalLinkClause}(${lineAndColumnClause})`); } </del> protected _isLinkActivationModifierDown(event: MouseEvent): boolean { const editorConf = this._configurationService.getValue<{ multiCursorModifier: 'ctrlCmd' | 'alt' }>('editor'); if (editorConf.multiCursorModifier === 'ctrlCmd') {


scheme: 'file', path: '/path/test.file', fsPath: '/path/test.file'.replace(///g, isWindows ? '' : '/'), <ins> _sep: isWindows ? 1 : undefined, </ins> external: 'file:///path/test.file' }); });


} } <ins> export class CamelCaseAction extends AbstractCaseAction { public static wordBoundary = new BackwardsCompatibleRegExp('[_s-]', 'gm'); constructor() { super({ id: 'editor.action.transformToCamelcase', label: nls.localize('editor.transformToCamelcase', "Transform to Camel Case"), alias: 'Transform to Camel Case', precondition: EditorContextKeys.writable }); } protected _modifyText(text: string, wordSeparators: string): string { const wordBoundary = CamelCaseAction.wordBoundary.get(); if (!wordBoundary) { // cannot support this return text; } const words = text.split(wordBoundary); const firstWord = words.shift(); return firstWord + words.map((word: string) => word.substring(0, 1).toLocaleUpperCase() + word.substring(1)) .join(''); } } </ins> export class KebabCaseAction extends AbstractCaseAction { public static isSupported(): boolean {


*--------------------------------------------------------------------------------------------*/ import * as fs from 'fs'; <del> import { l10n } from 'vscode'; </del> import { IPCClient } from './ipc/ipcClient'; function fatal(err: any): void { <del> console.error(l10n.t('Missing or invalid credentials.')); </del> <ins> console.error('Missing or invalid credentials.'); </ins> console.error(err); process.exit(1); }


url = url.trim().replace(/^gits+clones+/, ''); <del> const config = workspace.getConfiguration('git'); let defaultCloneDirectory = config.get<string>('defaultCloneDirectory') || os.homedir(); defaultCloneDirectory = defaultCloneDirectory.replace(/^~/, os.homedir()); const uris = await window.showOpenDialog({ canSelectFiles: false, canSelectFolders: true, canSelectMany: false, defaultUri: Uri.file(defaultCloneDirectory), openLabel: localize('selectFolder', "Select Repository Location") }); </del> <ins> if (!parentPath) { const config = workspace.getConfiguration('git'); let defaultCloneDirectory = config.get<string>('defaultCloneDirectory') || os.homedir(); defaultCloneDirectory = defaultCloneDirectory.replace(/^~/, os.homedir()); </ins> <del> if (!uris || uris.length === 0) { /* __GDPR__ "clone" : { "outcome" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" } } */ this.telemetryReporter.sendTelemetryEvent('clone', { outcome: 'no_directory' }); return; } </del> <ins> const uris = await window.showOpenDialog({ canSelectFiles: false, canSelectFolders: true, canSelectMany: false, defaultUri: Uri.file(defaultCloneDirectory), openLabel: localize('selectFolder', "Select Repository Location") }); </ins> <del> const uri = uris[0]; const parentPath = uri.fsPath; </del> <ins> if (!uris || uris.length === 0) { /* __GDPR__ "clone" : { "outcome" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" } } */ this.telemetryReporter.sendTelemetryEvent('clone', { outcome: 'no_directory' }); return; } const uri = uris[0]; parentPath = uri.fsPath; } </ins> try { const opts = {


this.debugStartLanguageContext.set(lastSetLanguage); const setContextKey = () => { <del> const editorControl = this.editorService.activeTextEditorControl; </del> <ins> let editorControl = this.editorService.activeTextEditorControl; if (isDiffEditor(editorControl)) { editorControl = editorControl.getModifiedEditor(); } </ins> if (isCodeEditor(editorControl)) { const model = editorControl.getModel(); const language = model ? model.getLanguageId() : undefined;


this.registerContinueInLocalFolderAction(); <ins> this.registerShowEditSessionViewAction(); </ins> this.registered = true; } <ins> private registerShowEditSessionViewAction() { const that = this; this._register(registerAction2(class ShowEditSessionView extends Action2 { constructor() { super({ id: 'workbench.editSessions.actions.showEditSessions', title: { value: localize('show edit session', "Show Edit Sessions"), original: 'Show Edit Sessions' }, category: EDIT_SESSION_SYNC_CATEGORY, f1: true, precondition: EDIT_SESSIONS_SIGNED_IN }); } async run(accessor: ServicesAccessor) { that.shouldShowViewsContext.set(true); const viewsService = accessor.get(IViewsService); await viewsService.openViewContainer(EDIT_SESSIONS_CONTAINER_ID); } })); } </ins> private registerContinueEditSessionAction() { const that = this; this._register(registerAction2(class ContinueEditSessionAction extends Action2 {


* { language: 'typescript', scheme: 'file' } * * @example <caption>A language filter that applies to all package.json paths</caption> <del> * { language: 'json', scheme: 'untitled', pattern: '**/package.json' } </del> <ins> * { language: 'json', pattern: '**/package.json' } </ins> */ export interface DocumentFilter {


if (cellDragEvent) { handler(cellDragEvent); } <del> })); </del> <ins> }, useCapture)); </ins> }; addCellDragListener(DOM.EventType.DRAG_OVER, event => { <ins> if (!this.currentDraggedCell) { return; } </ins> event.browserEvent.preventDefault(); <ins> event.browserEvent.stopImmediatePropagation(); </ins> this.onCellDragover(event); <del> }); </del> <ins> }, true); </ins> addCellDragListener(DOM.EventType.DROP, event => { <ins> if (!this.currentDraggedCell) { return; } </ins> event.browserEvent.preventDefault(); this.onCellDrop(event); });


private _busy = false; private _ignoreFocusOut = false; private _buttons: IQuickInputButton[] = []; <ins> private buttonsUpdated = false; private _toggles: IQuickInputToggle[] = []; private togglesUpdated = false; </ins> protected noValidationMessage = QuickInput.noPromptMessage; private _validationMessage: string | undefined; private _lastValidationMessage: string | undefined; private _severity: Severity = Severity.Ignore; private _lastSeverity: Severity | undefined; <del> private buttonsUpdated = false; </del> private readonly onDidTriggerButtonEmitter = this._register(new Emitter<IQuickInputButton>()); private readonly onDidHideEmitter = this._register(new Emitter<IQuickInputHideEvent>()); private readonly onDisposeEmitter = this._register(new Emitter<void>());


label: localize('neverAgain', "Don't Show Again"), isSecondary: true, run: () => { <del> languagePackSuggestionIgnoreList.push(language); </del> <ins> languagePackSuggestionIgnoreList.push(locale); </ins> this.storageService.store( LANGUAGEPACK_SUGGESTION_IGNORE_STORAGE_KEY, JSON.stringify(languagePackSuggestionIgnoreList),


export function restoreRecentlyOpened(data: RecentlyOpenedStorageData | undefined, logService: ILogService): IRecentlyOpened { const result: IRecentlyOpened = { workspaces: [], files: [] }; if (data) { <del> const restoreGracefully = function <T>(entries: T[], func: (entry: T, index: number) => void) { </del> <ins> const restoreGracefully = function <T>(entries: T[], onEntry: (entry: T, index: number) => void) { </ins> for (let i = 0; i < entries.length; i++) { try { <del> func(entries[i], i); </del> <ins> onEntry(entries[i], i); </ins> } catch (e) { logService.warn(`Error restoring recent entry ${JSON.stringify(entries[i])}: ${e.toString()}. Skip entry.`); }


} getAriaLabel(element: ListElement): string | null { <del> return element.saneAriaLabel; </del> <ins> return element.separator?.label ? `${element.saneAriaLabel}, ${element.separator.label}` : element.saneAriaLabel; </ins> } getWidgetRole() {


<array> <dict> <key>begin</key> <del> <string>/**</string> </del> <ins> <string>/**(?!/)</string> </ins> <key>captures</key> <dict> <key>0</key>


const others = distinct([ ...Object.keys(this._exeBasedRecommendations), ...this._dynamicWorkspaceRecommendations, <del> ...Object.keys(this._experimentalRecommendations)]); </del> <ins> ...Object.keys(this._experimentalRecommendations), ]); </ins> shuffle(others); <del> return others.map(extensionId => { const sources: ExtensionRecommendationSource[] = []; if (this._exeBasedRecommendations[extensionId]) { sources.push('executable'); } if (this._dynamicWorkspaceRecommendations[extensionId]) { sources.push('dynamic'); } return (<IExtensionRecommendation>{ extensionId, sources }); }); </del> <ins> return [ ...this.getRestoredRecommendationsByReason(ExtensionRecommendationReason.Executable), ...this.getRestoredRecommendationsByReason(ExtensionRecommendationReason.DynamicWorkspace), ...this.getRestoredRecommendationsByReason(ExtensionRecommendationReason.Experimental), ...others] .map(extensionId => { const sources: ExtensionRecommendationSource[] = []; if (this._exeBasedRecommendations[extensionId]) { sources.push('executable'); } if (this._dynamicWorkspaceRecommendations[extensionId]) { sources.push('dynamic'); } if (this._sessionRestoredRecommendations[extensionId.toLowerCase()]) { sources.push(...this._sessionRestoredRecommendations[extensionId.toLowerCase()].sources); } return (<IExtensionRecommendation>{ extensionId, sources }); }); </ins> }); } <ins> private getRestoredRecommendationsByReason(reason: ExtensionRecommendationReason): string[] { return Object.keys(this._sessionRestoredRecommendations).filter(key => this._sessionRestoredRecommendations[key].reasonId === reason); } </ins> getKeymapRecommendations(): IExtensionRecommendation[] { return (product.keymapExtensionTips || []).map(extensionId => (<IExtensionRecommendation>{ extensionId, sources: ['application'] })); }


id: MenuId.NotebookCellTitle, when: ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_EDITABLE), group: CellOverflowToolbarGroups.Copy, <ins> order: 1, </ins> }, keybinding: platform.isNative ? undefined : { when: ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey)),


import { CodeCellViewModel } from 'vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel'; import { URI } from 'vs/base/common/uri'; import { Event } from 'vs/base/common/event'; <ins> import { IChatAgentService } from 'vs/workbench/contrib/chat/common/chatAgents'; </ins> type CellDiagnostic = { cellUri: URI;


location: ProgressLocation.Notification, title: progressStartEvent.body.title, cancellable: progressStartEvent.body.cancellable, <del> priority: NotificationPriority.SILENT, </del> source, delay: 500 }, progressStep => {


import { ICodeEditor } from 'vs/editor/browser/editorBrowser'; import { IEditorOptions } from 'vs/editor/common/config/editorOptions'; import { TextEditorOptions, EditorModel, EditorInput, EditorOptions } from 'vs/workbench/common/editor'; <ins> import { ResourceEditorInput } from 'vs/workbench/common/editor/resourceEditorInput'; </ins> import { BaseTextEditorModel } from 'vs/workbench/common/editor/textEditorModel'; import { UntitledEditorInput } from 'vs/workbench/common/editor/untitledEditorInput'; import { BaseTextEditor } from 'vs/workbench/browser/parts/editor/textEditor';


const editorOptions = this._configurationService.getValue<IEditorOptions>('editor'); const xterm = new Terminal({ <ins> altClickMovesCursor: config.altClickMovesCursor, </ins> scrollback: config.scrollback, theme: this._getXtermTheme(), drawBoldTextInBrightColors: config.drawBoldTextInBrightColors,


args.push('--ignore-submodules'); } <del> if (opts?.similarityThreshold) { </del> <ins> // --find-renames option is only available starting with git 2.18.0 if (opts?.similarityThreshold && this._git.compareGitVersionTo('2.18.0') !== -1) { </ins> args.push(`--find-renames=${opts.similarityThreshold}%`); }


<del> 2019-08-30T20:24:23.714Z </del> <ins> 2020-10-05T20:24:23.714Z </ins>


type: 'boolean', default: true, description: nls.localize('comments.visible', "Controls the visibility of the comments bar and comment threads in editors that have commenting ranges and comments. Comments are still accessible via the Comments view and will cause commenting to be toggled on in the same way running the command "Comments: Toggle Editor Commenting" toggles comments.") <ins> }, 'comments.maxHeight': { type: 'boolean', default: true, description: nls.localize('comments.maxHeight', "Controls whether the comments widget scrolls or expands.") </ins> } } });


import { IPreferencesService } from 'vs/workbench/services/preferences/common/preferences'; import { ILogService } from 'vs/platform/log/common/log'; import { IChatService } from 'vs/workbench/contrib/chat/common/chatService'; <ins> import { CONTEXT_IN_CHAT_INPUT } from 'vs/workbench/contrib/chat/common/chatContextKeys'; </ins> CommandsRegistry.registerCommandAlias('interactiveEditor.start', 'inlineChat.start'); CommandsRegistry.registerCommandAlias('interactive.acceptChanges', ACTION_ACCEPT_CHANGES);


private _lastAcceptedCompletionTimestamp: number = 0; private _lastUserData?: string; <ins> isPasting: boolean = false; </ins> static requestCompletionsSequence = 'x1b[24~e'; // F12,e static requestGlobalCompletionsSequence = 'x1b[24~f'; // F12,f static requestEnableGitCompletionsSequence = 'x1b[24~g'; // F12,g


"keybindingLabel.foreground": "#000000e4", "list.activeSelectionBackground": "#e8e8e8", "list.activeSelectionForeground": "#000000", <del> "list.activeSelectionIconForeground": "#000000", </del> "list.hoverBackground": "#f2f2f2", "menu.border": "#D4D4D4", "notebook.cellBorderColor": "#E8E8E8",


if (selections) { const ranges: ILineRange[] = []; for (const selection of selections) { <del> let endLineNumber = selection.endLineNumber; if (selection.endColumn === 1) { --endLineNumber; } const startLineNumber = selection.startLineNumber; ranges.push(endLineNumber >= selection.startLineNumber ? { startLineNumber, endLineNumber } : { endLineNumber, startLineNumber }); </del> <ins> const { startLineNumber, endLineNumber } = selection; ranges.push(endLineNumber >= startLineNumber ? { startLineNumber, endLineNumber } : { endLineNumber, startLineNumber }); </ins> } foldingModel.removeManualRanges(ranges); foldingController.triggerFoldingModelChanged();


const historyItemGroupHoverLabelForegroundColor = colorTheme.getColor(historyItemGroupHoverLabelForeground); markdown.appendMarkdown(`nn---nn`); <del> markdown.appendMarkdown(historyItem.labels.map(label => { </del> <ins> markdown.appendMarkdown(historyItemLabels.map(label => { </ins> const historyItemGroupHoverLabelBackgroundColor = label.title === currentHistoryItemGroup?.name ? historyItemGroupLocalColor : label.title === currentHistoryItemGroup?.remote?.name ? historyItemGroupRemoteColor :


$openTunnel(tunnelOptions: TunnelOptions, source: string | undefined): Promise<TunnelDto | undefined>; $closeTunnel(remote: { host: string; port: number }): Promise<void>; $getTunnels(): Promise<TunnelDescription[]>; <del> $setTunnelProvider(features?: TunnelProviderFeatures): Promise<void>; </del> <ins> $setTunnelProvider(features: TunnelProviderFeatures | undefined, enablePortsView: boolean): Promise<void>; </ins> $setRemoteTunnelService(processId: number): Promise<void>; $setCandidateFilter(): Promise<void>; $onFoundNewCandidates(candidates: CandidatePort[]): Promise<void>;


return this._remoteAuthority.options.isTrusted; } <del> if (this.environmentService.extensionTestsLocationURI) { return true; // trust running tests with vscode-test } </del> if (this.workspaceService.getWorkbenchState() === WorkbenchState.EMPTY) { // Use memento if present, otherwise default to restricted mode // Workspace may transition to trusted based on the opened editors return this._trustState.isTrusted ?? false; } <ins> if (!this._initialized) { return false; } </ins> return this.getUrisTrust(this.getWorkspaceUris()); }


isExtensionCustomPtyTerminal: true, icon: iconPath, color: ThemeColor.isThemeColor(color) ? color.id : undefined, <del> location: this._serializeParentTerminal(location, parentTerminal), </del> <ins> location: internalOptions?.location || this._serializeParentTerminal(location, parentTerminal), </ins> isTransient: true }); // At this point, the id has been set via `$acceptTerminalOpened`


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ import { ExtensionContext, NotebookCellKind, NotebookDocument, NotebookDocumentChangeEvent, NotebookEdit, workspace, WorkspaceEdit, type NotebookCell, type NotebookDocumentWillSaveEvent } from 'vscode'; import { getCellMetadata, getVSCodeCellLanguageId, removeVSCodeCellLanguageId, setVSCodeCellLanguageId } from './serializers'; import { CellMetadata } from './common'; import { getNotebookMetadata } from './notebookSerializer'; import type * as nbformat from '@jupyterlab/nbformat'; const noop = () => { // }; /** * Code here is used to ensure the Notebook Model is in sync the the ipynb JSON file. * E.g. assume you add a new cell, this new cell will not have any metadata at all. * However when we save the ipynb, the metadata will be an empty object `{}`. * Now thats completely different from the metadata os being `empty/undefined` in the model. * As a result, when looking at things like diff view or accessing metadata, we'll see differences. * * This code ensures that the model is in sync with the ipynb file. */ export const pendingNotebookCellModelUpdates = new WeakMap<NotebookDocument, Set<Thenable<void>>>(); export function activate(context: ExtensionContext) { workspace.onDidChangeNotebookDocument(onDidChangeNotebookCells, undefined, context.subscriptions); workspace.onWillSaveNotebookDocument(waitForPendingModelUpdates, undefined, context.subscriptions); } function isSupportedNotebook(notebook: NotebookDocument) { return notebook.notebookType === 'jupyter-notebook' || notebook.notebookType === 'interactive'; } function waitForPendingModelUpdates(e: NotebookDocumentWillSaveEvent) { if (!isSupportedNotebook(e.notebook)) { return; } const promises = pendingNotebookCellModelUpdates.get(e.notebook); if (!promises) { return; } e.waitUntil(Promise.all(promises)); } function cleanup(notebook: NotebookDocument, promise: PromiseLike<void>) { const pendingUpdates = pendingNotebookCellModelUpdates.get(notebook); if (pendingUpdates) { pendingUpdates.delete(promise); if (!pendingUpdates.size) { pendingNotebookCellModelUpdates.delete(notebook); } } } function trackAndUpdateCellMetadata(notebook: NotebookDocument, cell: NotebookCell, metadata: CellMetadata & { vscode?: { languageId: string } }) { const pendingUpdates = pendingNotebookCellModelUpdates.get(notebook) ?? new Set<Thenable<void>>(); pendingNotebookCellModelUpdates.set(notebook, pendingUpdates); const edit = new WorkspaceEdit(); edit.set(cell.notebook.uri, [NotebookEdit.updateCellMetadata(cell.index, { ...(cell.metadata), custom: metadata })]); const promise = workspace.applyEdit(edit).then(noop, noop); pendingUpdates.add(promise); const clean = () => cleanup(notebook, promise); promise.then(clean, clean); } function onDidChangeNotebookCells(e: NotebookDocumentChangeEvent) { if (!isSupportedNotebook(e.notebook)) { return; } const notebook = e.notebook; const notebookMetadata = getNotebookMetadata(e.notebook); // use the preferred language from document metadata or the first cell language as the notebook preferred cell language const preferredCellLanguage = notebookMetadata.metadata?.language_info?.name; // When we change the language of a cell, // Ensure the metadata in the notebook cell has been updated as well, // Else model will be out of sync with ipynb https://github.com/microsoft/vscode/issues/207968#issuecomment-2002858596 e.cellChanges.forEach(e => { if (!preferredCellLanguage || e.cell.kind !== NotebookCellKind.Code) { return; } const languageIdInMetadata = getVSCodeCellLanguageId(getCellMetadata(e.cell)); if (e.cell.document.languageId !== preferredCellLanguage && e.cell.document.languageId !== languageIdInMetadata) { const metadata: CellMetadata = JSON.parse(JSON.stringify(getCellMetadata(e.cell))); metadata.metadata = metadata.metadata || {}; setVSCodeCellLanguageId(metadata, e.cell.document.languageId); trackAndUpdateCellMetadata(notebook, e.cell, metadata); } else if (e.cell.document.languageId === preferredCellLanguage && languageIdInMetadata) { const metadata: CellMetadata = JSON.parse(JSON.stringify(getCellMetadata(e.cell))); metadata.metadata = metadata.metadata || {}; removeVSCodeCellLanguageId(metadata); trackAndUpdateCellMetadata(notebook, e.cell, metadata); } else if (e.cell.document.languageId === preferredCellLanguage && e.cell.document.languageId === languageIdInMetadata) { const metadata: CellMetadata = JSON.parse(JSON.stringify(getCellMetadata(e.cell))); metadata.metadata = metadata.metadata || {}; removeVSCodeCellLanguageId(metadata); trackAndUpdateCellMetadata(notebook, e.cell, metadata); } }); // Ensure all new cells in notebooks with nbformat >= 4.5 have an id. // Details of the spec can be found here https://jupyter.org/enhancement-proposals/62-cell-id/cell-id.html# e.contentChanges.forEach(change => { change.addedCells.forEach(cell => { // When ever a cell is added, always update the metadata // as metadata is always an empty `{}` in ipynb JSON file const cellMetadata = getCellMetadata(cell); // Avoid updating the metadata if it's not required. if (cellMetadata.metadata) { if (!isCellIdRequired(notebookMetadata)) { return; } if (isCellIdRequired(notebookMetadata) && cellMetadata?.id) { return; } } // Don't edit the metadata directly, always get a clone (prevents accidental singletons and directly editing the objects). const metadata: CellMetadata = { ...JSON.parse(JSON.stringify(cellMetadata || {})) }; metadata.metadata = metadata.metadata || {}; if (isCellIdRequired(notebookMetadata) && !cellMetadata?.id) { metadata.id = generateCellId(e.notebook); } trackAndUpdateCellMetadata(notebook, cell, metadata); }); }); } /** * Cell ids are required in notebooks only in notebooks with nbformat >= 4.5 */ function isCellIdRequired(metadata: Pick<Partial<nbformat.INotebookContent>, 'nbformat' | 'nbformat_minor'>) { if ((metadata.nbformat || 0) >= 5) { return true; } if ((metadata.nbformat || 0) === 4 && (metadata.nbformat_minor || 0) >= 5) { return true; } return false; } function generateCellId(notebook: NotebookDocument) { while (true) { // Details of the id can be found here https://jupyter.org/enhancement-proposals/62-cell-id/cell-id.html#adding-an-id-field, // & here https://jupyter.org/enhancement-proposals/62-cell-id/cell-id.html#updating-older-formats const id = generateUuid().replace(/-/g, '').substring(0, 8); let duplicate = false; for (let index = 0; index < notebook.cellCount; index++) { const cell = notebook.cellAt(index); const existingId = getCellMetadata(cell)?.id; if (!existingId) { continue; } if (existingId === id) { duplicate = true; break; } } if (!duplicate) { return id; } } } /** * Copied from src/vs/base/common/uuid.ts */ function generateUuid() { // use `randomValues` if possible function getRandomValues(bucket: Uint8Array): Uint8Array { for (let i = 0; i < bucket.length; i++) { bucket[i] = Math.floor(Math.random() * 256); } return bucket; } // prep-work const _data = new Uint8Array(16); const _hex: string[] = []; for (let i = 0; i < 256; i++) { _hex.push(i.toString(16).padStart(2, '0')); } // get data getRandomValues(_data); // set version bits _data[6] = (_data[6] & 0x0f) | 0x40; _data[8] = (_data[8] & 0x3f) | 0x80; // print as string let i = 0; let result = ''; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += '-'; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += '-'; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += '-'; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += '-'; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; result += _hex[_data[i++]]; return result; } </ins>


import * as vscode from 'vscode'; import { NotebookSerializer } from './notebookSerializer'; <del> import { ensureAllNewCellsHaveCellIds } from './cellIdService'; </del> <ins> import { activate as keepNotebookModelStoreInSync } from './notebookModelStoreSync'; </ins> import { notebookImagePasteSetup } from './notebookImagePaste'; import { AttachmentCleaner } from './notebookAttachmentCleaner';


} // Refresh Parent (View) await this.view?.refresh(shouldDeepRefresh, parent); <ins> if (this.view?.getFocus().length === 0) { this.view?.focusLast(); } </ins> } })); }


export interface RenderOutput { html: string; <del> containingImages: { src: string }[]; </del> <ins> containingImages: Set<string>; </ins> } interface RenderEnv { <del> containingImages: { src: string }[]; </del> <ins> containingImages: Set<string>; </ins> currentDocument: vscode.Uri | undefined; resourceProvider: WebviewResourceProvider | undefined; }


@IWorkbenchThemeService protected themeService: IWorkbenchThemeService, @INotificationService private notificationService: INotificationService, @ICommandService private commandService: ICommandService, <ins> @IExtensionService private extensionService: IExtensionService, </ins> @IContextMenuService private contextMenuService: IContextMenuService, <ins> @IKeybindingService private keybindingService: IKeybindingService, </ins> @ITelemetryService private telemetryService: ITelemetryService, @IWorkspaceEditingService private workspaceEditingService: IWorkspaceEditingService, @IFileService private fileService: IFileService,


this.debugService.getModel().getSessions().forEach(registerLoadedSourceListener); this.disposables.push(this.debugService.onDidEndSession(session => { <del> clearTimeout(timeout); </del> root.remove(session.getId()); <del> if (this.tree) { this.tree.refresh(root, false); } </del> <ins> this.treeRefreshScheduler.schedule(); </ins> })); }


this.textArea.setAttribute('aria-haspopup', 'false'); this.textArea.setAttribute('aria-autocomplete', 'both'); <del> if (options.get(EditorOption.domReadOnly)) { </del> <ins> if (options.get(EditorOption.domReadOnly) && options.get(EditorOption.readOnly)) { </ins> this.textArea.setAttribute('readonly', 'true'); }


import { isIOS } from 'vs/base/common/platform'; import Severity from 'vs/base/common/severity'; import { ThemeIcon } from 'vs/base/common/themables'; <del> import { isString, withNullAsUndefined } from 'vs/base/common/types'; </del> <ins> import { isString, withNullAsUndefined, withUndefinedAsNull } from 'vs/base/common/types'; </ins> import 'vs/css!./media/quickInput'; import { localize } from 'vs/nls'; import { ILayoutService } from 'vs/platform/layout/browser/layoutService';


"build-notebook": "node ./esbuild" }, "dependencies": { <del> "@vscode/markdown-it-katex": "^1.0.3" </del> <ins> "@vscode/markdown-it-katex": "^1.1.0" </ins> }, "devDependencies": { "@types/markdown-it": "^0.0.0",


'properties': { 'workbench.startupEditor': { 'type': 'string', <del> 'enum': ['none', 'welcomePage', 'newUntitledFile'], </del> <ins> 'enum': ['none', 'welcomePage', 'newUntitledFile', 'welcomePageInEmptyWorkbench'], </ins> 'enumDescriptions': [ localize({ comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'workbench.startupEditor.none' }, "Start without an editor."), localize({ comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'workbench.startupEditor.welcomePage' }, "Open the Welcome page (default)."), localize({ comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'workbench.startupEditor.newUntitledFile' }, "Open a new untitled file (only applies when opening an empty workspace)."), <ins> localize({ comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'workbench.startupEditor.welcomePageInEmptyWorkbench' }, "Open the Welcome page when opening an empty workbench."), </ins> ], 'default': 'welcomePage', 'description': localize('workbench.startupEditor', "Controls which editor is shown at startup, if none are restored from the previous session.")


const original = md.renderer.rules.image; md.renderer.rules.image = (tokens: Token[], idx: number, options, env: RenderEnv, self) => { const token = tokens[idx]; <del> token.attrJoin('class', 'loading'); </del> const src = token.attrGet('src'); if (src) { <del> env.containingImages?.push({ src }); const imgHash = stringHash(src); token.attrSet('id', `image-hash-${imgHash}`); </del> <ins> env.containingImages?.add(src); </ins> if (!token.attrGet('data-src')) { token.attrSet('src', this.toResourceUri(src, env.currentDocument, env.resourceProvider));


"configuration.suggest.completeFunctionCalls": "Complete functions with their parameter signature.", "configuration.suggest.includeAutomaticOptionalChainCompletions": "Enable/disable showing completions on potentially undefined values that insert an optional chain call. Requires strict null checks to be enabled.", "configuration.suggest.includeCompletionsForImportStatements": "Enable/disable auto-import-style completions on partially-typed import statements.", <del> "configuration.suggest.includeCompletionsWithSnippetText": "Enable/disable snippet completions from TS Server.", </del> "typescript.tsdk.desc": "Specifies the folder path to the tsserver and `lib*.d.ts` files under a TypeScript install to use for IntelliSense, for example: `./node_modules/typescript/lib`.nn- When specified as a user setting, the TypeScript version from `typescript.tsdk` automatically replaces the built-in TypeScript version.n- When specified as a workspace setting, `typescript.tsdk` allows you to switch to use that workspace version of TypeScript for IntelliSense with the `TypeScript: Select TypeScript version` command.nnSee the [TypeScript documentation](https://code.visualstudio.com/docs/typescript/typescript-compiling#_using-newer-typescript-versions) for more detail about managing TypeScript versions.", "typescript.disableAutomaticTypeAcquisition": "Disables [automatic type acquisition](https://code.visualstudio.com/docs/nodejs/working-with-javascript#_typings-and-automatic-type-acquisition). Automatic type acquisition fetches `@types` packages from npm to improve IntelliSense for external libraries.", "typescript.enablePromptUseWorkspaceTsdk": "Enables prompting of users to use the TypeScript version configured in the workspace for Intellisense.",


class TestParcelWatcher extends ParcelWatcher { <del> testNormalizePaths(paths: string[]): string[] { </del> <ins> testNormalizePaths(paths: string[], excludes: string[] = []): string[] { </ins> // Work with strings as paths to simplify testing const requests: IRecursiveWatchRequest[] = paths.map(path => { <del> return { path, excludes: [], recursive: true }; </del> <ins> return { path, excludes, recursive: true }; </ins> }); return this.normalizeRequests(requests).map(request => request.path);


this._list.triggerScrollFromMouseWheelEvent(event); } <ins> previousChange(): void { let currFocus = this._list.getFocus()[0]; if (isNaN(currFocus) || currFocus < 0) { currFocus = 0; } // find the index of previous change let prevChangeIndex = currFocus - 1; while (prevChangeIndex >= 0) { const vm = this._diffElementViewModels[prevChangeIndex]; if (vm.type !== 'unchanged') { break; } prevChangeIndex--; } if (prevChangeIndex >= 0) { this._list.setFocus([prevChangeIndex]); this._list.reveal(prevChangeIndex); } else { // go to the last one const index = lastIndex(this._diffElementViewModels, vm => vm.type !== 'unchanged'); if (index >= 0) { this._list.setFocus([index]); this._list.reveal(index); } } } nextChange(): void { let currFocus = this._list.getFocus()[0]; if (isNaN(currFocus) || currFocus < 0) { currFocus = 0; } // find the index of next change let nextChangeIndex = currFocus + 1; while (nextChangeIndex < this._diffElementViewModels.length) { const vm = this._diffElementViewModels[nextChangeIndex]; if (vm.type !== 'unchanged') { break; } nextChangeIndex++; } if (nextChangeIndex < this._diffElementViewModels.length) { this._list.setFocus([nextChangeIndex]); this._list.reveal(nextChangeIndex); } else { // go to the first one const index = this._diffElementViewModels.findIndex(vm => vm.type !== 'unchanged'); if (index >= 0) { this._list.setFocus([index]); this._list.reveal(index); } } } </ins> createOutput(cellDiffViewModel: DiffElementViewModelBase, cellViewModel: DiffNestedCellViewModel, output: IInsetRenderOutput, getOffset: () => number, diffSide: DiffSide): void { this._insetModifyQueueByOutputId.queue(output.source.model.outputId + (diffSide === DiffSide.Modified ? '-right' : 'left'), async () => { const activeWebview = diffSide === DiffSide.Modified ? this._modifiedWebview : this._originalWebview;


return true; }); <del> for (const placeholder of incompletePlaceholders) { </del> <ins> const fillInIncompletePlaceholder = (placeholder: Placeholder, stack: Set<number>) => { </ins> const defaultValues = placeholderDefaultValues.get(placeholder.index); <del> if (defaultValues) { const clone = new Placeholder(placeholder.index); clone.transform = placeholder.transform; for (const child of defaultValues) { clone.appendChild(child.clone()); </del> <ins> if (!defaultValues) { return; } const clone = new Placeholder(placeholder.index); clone.transform = placeholder.transform; for (const child of defaultValues) { const newChild = child.clone(); clone.appendChild(newChild); // "recurse" on children that are again placeholders if (newChild instanceof Placeholder && placeholderDefaultValues.has(newChild.index) && !stack.has(newChild.index)) { stack.add(newChild.index); fillInIncompletePlaceholder(newChild, stack); stack.delete(newChild.index); </ins> } <del> snippet.replace(placeholder, [clone]); </del> } <ins> snippet.replace(placeholder, [clone]); }; const stack = new Set<number>(); for (const placeholder of incompletePlaceholders) { fillInIncompletePlaceholder(placeholder, stack); </ins> } return snippet.children.slice(offset);


import { IRange, Range } from 'vs/editor/common/core/range'; import { getDefinitionsAtPosition } from 'vs/editor/contrib/gotoSymbol/browser/goToSymbol'; import { goToDefinitionWithLocation } from 'vs/editor/contrib/inlayHints/browser/inlayHintsLocations'; <del> import { Position } from 'vs/editor/common/core/position'; </del> <ins> import { IPosition, Position } from 'vs/editor/common/core/position'; </ins> import { CancellationTokenSource } from 'vs/base/common/cancellation'; import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry'; import { ILanguageFeatureDebounceService } from 'vs/editor/common/services/languageFeatureDebounce';


} canSerialize(): boolean { <del> return this.configurationService.getValue<boolean>(InteractiveWindowSetting.interactiveWindowHotExit); </del> <ins> return this.configurationService.getValue<boolean>(InteractiveWindowSetting.interactiveWindowRestore); </ins> } serialize(input: EditorInput): string {


${vscode.l10n.t("Focus Lock")}


this.contextKeyService = service; } <ins> private filterNonUniversalActions(groups: Map<string, IAction>[], newActions: IAction[]) { const newActionsSet: Set<string> = new Set(newActions.map(a => a.id)); for (const group of groups) { const actions = group.keys(); for (const action of actions) { if (!newActionsSet.has(action)) { group.delete(action); } } } } private buildMenu(groups: Map<string, IAction>[]): IAction[] { const result: IAction[] = []; for (const group of groups) { if (group.size > 0) { if (result.length) { result.push(new Separator()); } result.push(...group.values()); } } return result; } private createGroups(actions: IAction[]): Map<string, IAction>[] { const groups: Map<string, IAction>[] = []; let group: Map<string, IAction> = new Map(); for (const action of actions) { if (action instanceof Separator) { groups.push(group); group = new Map(); } else { group.set(action.id, action); } } groups.push(group); return groups; } </ins> private getActions(menuId: MenuId, elements: ITreeItem[], listen?: DisposableStore): { primary: IAction[]; secondary: IAction[] } { if (!this.contextKeyService) { return { primary: [], secondary: [] }; } <del> const allowedPrimary = new Map<string, IAction>(); const allowedSecondary = new Map<string, IAction>(); </del> <ins> let primaryGroups: Map<string, IAction>[] = []; let secondaryGroups: Map<string, IAction>[] = []; </ins> for (let i = 0; i < elements.length; i++) { const element = elements[i]; const contextKeyService = this.contextKeyService.createOverlay([


// Extensions Management else if (shouldSpawnCliProcess(args)) { <del> const cli = await import(['vs', 'code', 'node', 'cliProcessMain'].join('/') /* TODO@esm workaround to prevent esbuild from inlining this */); </del> <ins> const cli = await import(['./cliProcessMain.js'].join('/') /* TODO@esm workaround to prevent esbuild from inlining this */); </ins> await cli.main(args); return;


import { ISimpleSelectedSuggestion } from 'vs/workbench/services/suggest/browser/simpleSuggestWidget'; import type { IMarker, ITheme, Terminal as RawXtermTerminal } from '@xterm/xterm'; import { ScrollPosition } from 'vs/workbench/contrib/terminal/browser/xterm/markNavigationAddon'; <ins> import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; </ins> export const ITerminalService = createDecorator<ITerminalService>('terminalService'); export const ITerminalEditorService = createDecorator<ITerminalEditorService>('terminalEditorService');


// Layout centered Editor (only in vertical layout when one group is opened) const id = this.visibleEditors[Position.ONE] ? this.visibleEditors[Position.ONE].getId() : undefined; <del> const doCentering = this.layoutVertically && this.partService.isEditorLayoutCentered() && this.stacks.groups.length === 1 && id !== PREFERENCES_EDITOR_ID && id !== TEXT_DIFF_EDITOR_ID; </del> <ins> const doCentering = this.partService.isEditorLayoutCentered() && this.stacks.groups.length === 1 && id !== PREFERENCES_EDITOR_ID && id !== TEXT_DIFF_EDITOR_ID; </ins> if (doCentering && !this.centeredEditorActive) { this.centeredEditorSashLeft.show(); this.centeredEditorSashRight.show(); // no size set yet. Calculate a default value <del> if (!this.centeredEditorPreferedSize) { </del> <ins> if (!this.centeredEditorPreferredSize) { </ins> this.resetCenteredEditor(false); } } else if (!doCentering && this.centeredEditorActive) {


return reject(new Error('Service Workers are not enabled. Webviews will not work. Try disabling private/incognito mode.')); } <del> const swPath = `service-worker.js${self.location.search}`; </del> <ins> const swPath = `service-worker.js?vscode-resource-base-authority=${(new URL(location.toString()).searchParams).get('vscode-resource-base-authority')}`; </ins> navigator.serviceWorker.register(swPath).then( async registration => {


return revive ? URI.revive(transformer.transformIncoming(obj)) : transformer.transformIncoming(obj); } <ins> if (obj instanceof VSBuffer) { return null; } </ins> // walk object (or array) for (const key in obj) { if (Object.hasOwnProperty.call(obj, key)) {


whenLabel.element.title = keybindingItemEntry.keybindingItem.when; } else { this.whenColumn.textContent = '—'; <ins> this.whenColumn.title = ''; </ins> } }


// In wait mode, listen to changes to the editors and wait until the files // are closed that the user wants to wait for. When this happens we delete // the wait marker file to signal to the outside that editing is done. <del> const resourcesToWaitFor = request.filesToWait.paths.map(p => URI.revive(p.fileUri)); </del> const waitMarkerFile = URI.revive(request.filesToWait.waitMarkerFileUri); <del> const unbind = this.editorService.onDidCloseEditor(() => { if (resourcesToWaitFor.every(resource => !this.editorService.isOpen({ resource }))) { unbind.dispose(); this.fileService.del(waitMarkerFile); </del> <ins> const resourcesToWaitFor = coalesce(request.filesToWait.paths.map(p => URI.revive(p.fileUri))); this.trackClosedWaitFiles(waitMarkerFile, resourcesToWaitFor); } } private trackClosedWaitFiles(waitMarkerFile: URI, resourcesToWaitFor: URI[]): IDisposable { const listener = this.editorService.onDidCloseEditor(async () => { // In wait mode, listen to changes to the editors and wait until the files // are closed that the user wants to wait for. When this happens we delete // the wait marker file to signal to the outside that editing is done. if (resourcesToWaitFor.every(resource => !this.editorService.isOpen({ resource }))) { // If auto save is configured with the default delay (1s) it is possible // to close the editor while the save still continues in the background. As such // we have to also check if the files to wait for are dirty and if so wait // for them to get saved before deleting the wait marker file. const dirtyFilesToWait = this.textFileService.getDirty(resourcesToWaitFor); if (dirtyFilesToWait.length > 0) { await Promise.all(dirtyFilesToWait.map(async dirtyFileToWait => await this.joinResourceSaved(dirtyFileToWait))); } listener.dispose(); await this.fileService.del(waitMarkerFile); } }); return listener; } private joinResourceSaved(resource: URI): Promise<void> { return new Promise(resolve => { if (!this.textFileService.isDirty(resource)) { return resolve(); // return early if resource is not dirty } // Otherwise resolve promise when resource is saved const listener = this.textFileService.models.onModelSaved(e => { if (isEqual(resource, e.resource)) { listener.dispose(); resolve(); </ins> } }); <del> } </del> <ins> }); </ins> } private openResources(resources: Array<IResourceInput | IUntitledResourceInput>, diffMode: boolean): void {


let lastPageIndex = this.view.indexAt(this.view.getScrollTop() + this.view.renderHeight); lastPageIndex = lastPageIndex === 0 ? 0 : lastPageIndex - 1; const lastPageElement = this.view.element(lastPageIndex); <del> const currentlyFocusedElement = this.getFocusedElements()[0]; </del> <ins> const currentlyFocusedElementIndex = this.getFocus()[0]; const currentlyFocusedElement = this.view.element(currentlyFocusedElementIndex); </ins> <del> if (currentlyFocusedElement !== lastPageElement) { </del> <ins> if (currentlyFocusedElement !== lastPageElement && lastPageIndex > currentlyFocusedElementIndex) { </ins> const lastGoodPageIndex = this.findPreviousIndex(lastPageIndex, false, filter); if (lastGoodPageIndex > -1 && currentlyFocusedElement !== this.view.element(lastGoodPageIndex)) {


} }; <del> type ConfigureTrustedDomainChoice = 'trustDomain' | 'trustSubdomain' | 'trustAll' | 'manage'; interface ConfigureTrustedDomainsQuickPickItem extends IQuickPickItem { id: ConfigureTrustedDomainChoice; } </del> <ins> type ConfigureTrustedDomainsQuickPickItem = IQuickPickItem & ({ id: 'manage'; } | { id: 'trust'; toTrust: string }); </ins> type ConfigureTrustedDomainsChoiceClassification = { choice: { classification: 'SystemMetaData', purpose: 'FeatureInsight' }; };


super({ id: 'editor.createFoldingRangeFromSelection', label: nls.localize('createManualFoldRange.label', "Create Manual Folding Range from Selection"), <del> alias: 'Create Folding Range from Selection', </del> <ins> alias: 'Create Manual Folding Range from Selection', </ins> precondition: CONTEXT_FOLDING_ENABLED, kbOpts: { kbExpr: EditorContextKeys.editorTextFocus,


return TriggerAction.CLOSE_PICKER; }, <del> accept: (keyMods, event) => this.openAnything(activeGlobalResource, { keyMods, range: editorSymbolPick.range?.selection, preserveFocus: event.inBackground }) </del> <ins> accept: (keyMods, event) => this.openAnything(activeGlobalResource, { keyMods, range: editorSymbolPick.range?.selection, preserveFocus: event.inBackground, forcePinned: event.inBackground }) </ins> }; }); }


const providerExists = isAbsolutePath(file); // Special case userdata as we don't have a search provider for it, but it can be searched. if (providerExists) { <del> const searchRoot = this.workspaceContextService.getWorkspaceFolder(file)?.uri ?? file.with({ path: path.dirname(file.fsPath) }); </del> <ins> const searchRoot = this.workspaceContextService.getWorkspaceFolder(file)?.uri ?? this.uriIdentityService.extUri.dirname(file); </ins> let folderQuery = foldersToSearch.get(searchRoot); if (!folderQuery) {


config.ariaLabel = ariaLabel || ''; config.cursorWidth = 1; config.snippetSuggestions = 'none'; <ins> config.suggest = { filterGraceful: false }; </ins> config.fontFamily = ' -apple-system, BlinkMacSystemFont, "Segoe WPC", "Segoe UI", "HelveticaNeue-Light", "Ubuntu", "Droid Sans", sans-serif'; return config; }


import { Schemas } from 'vs/base/common/network'; import { IDialogService, IConfirmationResult, IConfirmation, getConfirmMessage } from 'vs/platform/dialogs/common/dialogs'; import { INotificationService, Severity } from 'vs/platform/notification/common/notification'; <ins> import { Constants } from 'vs/editor/common/core/uint'; </ins> export interface IEditableData { action: IAction;


export const EDIT_SESSIONS_VIEW_ICON = registerIcon('edit-sessions-view-icon', Codicon.cloudDownload, localize('editSessionViewIcon', 'View icon of the edit sessions view.')); <ins> export const EDIT_SESSIONS_SHOW_VIEW = new RawContextKey<boolean>('editSessionsShowView', false); </ins> export const EDIT_SESSIONS_SCHEME = 'vscode-edit-sessions';


return authenticationSession !== undefined; } <ins> private cachedMachines: Map<string, string> | undefined; async getMachineById(machineId: string) { await this.initialize(false); if (!this.cachedMachines) { const machines = await this.machineClient!.getMachines(); this.cachedMachines = machines.reduce((map, machine) => map.set(machine.id, machine.name), new Map<string, string>()); } return this.cachedMachines.get(machineId); } private async getOrCreateCurrentMachineId(): Promise<string> { const currentMachineId = await this.machineClient!.getMachines().then((machines) => machines.find((m) => m.isCurrent)?.id); if (currentMachineId === undefined) { await this.machineClient!.addCurrentMachine(); return await this.machineClient!.getMachines().then((machines) => machines.find((m) => m.isCurrent)!.id); } return currentMachineId; } </ins> private async getAuthenticationSession(fromContinueOn: boolean) { // If the user signed in previously and the session is still available, reuse that without prompting the user again if (this.existingSessionId) {


import { HoverPosition } from 'vs/base/browser/ui/hover/hoverWidget'; import { verifiedPublisherIcon as verifiedPublisherThemeIcon } from 'vs/workbench/contrib/extensions/browser/extensionsIcons'; <del> export const EXTENSION_LIST_ELEMENT_HEIGHT = 62; </del> <ins> export const EXTENSION_LIST_ELEMENT_HEIGHT = 72; </ins> export interface IExtensionsViewState { onFocus: Event<IExtension>;


*/ this.telemetryService.publicLog('extensionsRecommendations:ignoreRecommendation', { id: extensionId, recommendationReason: reason.reasonId }); } <del> this._sessionIgnoredRecommendations[lowerId] = reason; </del> <ins> this._sessionIgnoredRecommendations[lowerId] = { ...reason, sources: coalesce([ <'executable' | null>(caseInsensitiveGet(this._exeBasedRecommendations, lowerId) ? 'executable' : null), ...(() => { let a = caseInsensitiveGet(this._fileBasedRecommendations, lowerId); return a ? a.sources : null; })(), <'dynamic' | null>(this._dynamicWorkspaceRecommendations.filter(x => x.toLowerCase() === lowerId).length > 0 ? 'dynamic' : null), ]) }; </ins> delete this._sessionRestoredRecommendations[lowerId]; this._globallyIgnoredRecommendations = distinct([...this._globallyIgnoredRecommendations, lowerId].map(id => id.toLowerCase())); } else {


} } <ins> export class CursorWordAccessibilityRight extends WordRightCommand { constructor() { super({ inSelectionMode: false, wordNavigationType: WordNavigationType.WordAccessibility, id: 'cursorWordAccessibilityRight', precondition: undefined }); } protected override _move(wordCharacterClassifier: WordCharacterClassifier, model: ITextModel, position: Position, wordNavigationType: WordNavigationType, hasMulticursor: boolean): Position { return super._move(getMapForWordSeparators(EditorOptions.wordSeparators.defaultValue, wordCharacterClassifier.intlSegmenterLocales), model, position, wordNavigationType, hasMulticursor); } } export class CursorWordAccessibilityRightSelect extends WordRightCommand { constructor() { super({ inSelectionMode: true, wordNavigationType: WordNavigationType.WordAccessibility, id: 'cursorWordAccessibilityRightSelect', precondition: undefined }); } protected override _move(wordCharacterClassifier: WordCharacterClassifier, model: ITextModel, position: Position, wordNavigationType: WordNavigationType, hasMulticursor: boolean): Position { return super._move(getMapForWordSeparators(EditorOptions.wordSeparators.defaultValue, wordCharacterClassifier.intlSegmenterLocales), model, position, wordNavigationType, hasMulticursor); } } </ins> export interface DeleteWordOptions extends ICommandOptions { whitespaceHeuristics: boolean; wordNavigationType: WordNavigationType;


// Titlebar let titlebarPart: IAuxiliaryTitlebarPart | undefined = undefined; let titlebarPartVisible = false; <del> const useCustomTitle = isNative && hasCustomTitlebar(this.configurationService); // custom title in aux windows only enabled in native </del> <ins> const useCustomTitle = isNative && !hasNativeTitlebar(this.configurationService); // custom title in aux windows only enabled in native </ins> if (useCustomTitle) { titlebarPart = disposables.add(this.titleService.createAuxiliaryTitlebarPart(auxiliaryWindow.container, editorPart)); titlebarPartVisible = true;


parsedLink.prefix?.index ?? parsedLink.path.index, parsedLink.suffix ? parsedLink.suffix.suffix.index + parsedLink.suffix.suffix.text.length : parsedLink.path.index + parsedLink.path.text.length ); <ins> this._logService.trace('terminalLocaLinkDetector#detect verified link', simpleLink); </ins> links.push(simpleLink); }


private readonly _onDidChangeQuickDiffProviders = this._register(new Emitter<void>()); readonly onDidChangeQuickDiffProviders = this._onDidChangeQuickDiffProviders.event; <ins> constructor(@IUriIdentityService private readonly uriIdentityService: IUriIdentityService) { super(); } </ins> addQuickDiffProvider(quickDiff: QuickDiffProvider): IDisposable { this.quickDiffProviders.add(quickDiff); this._onDidChangeQuickDiffProviders.fire();


private treeContainer: HTMLElement; private loadedScriptsItemType: IContextKey<string>; private settings: any; <ins> private shouldRefreshRecursive; </ins> constructor( options: IViewletViewOptions,


public sendText(text: string, addNewLine: boolean): void { this._processReady.then(() => { <del> text = this._sanitizeInput(text); </del> <ins> // Normalize line endings to 'enter' press. text = text.replace(TerminalInstance.EOL_REGEX, 'r'); </ins> if (addNewLine && text.substr(text.length - 1) !== 'r') { text += 'r'; }


newRemoteExtensionsMap.set(key, merge(key, localExtension, remoteExtension, localExtension)); } <del> // Locally removed extensions => exist in base and does not exit in local </del> <ins> // Locally removed extensions => exist in base and does not exist in local </ins> for (const key of baseToLocal.removed.values()) { // If updated in remote (already handled) if (baseToRemote.updated.has(key)) {


}); }); if (validatedLink) { <ins> map.set(originalLink, validatedLink); </ins> result.push(validatedLink); <ins> } else { map.set(originalLink, InvalidLinkResult); </ins> } }


renderedWordCount: number; lastRenderTime: number; isFullyRendered: boolean; <ins> originalMarkdown: IMarkdownString; </ins> } export interface IChatProgressMessageRenderData {


return action; }), { icon: true, label: false }); } <ins> if (this.togglesUpdated) { this.togglesUpdated = false; // HACK: Filter out toggles here that are not concrete Toggle objects. This is to workaround // a layering issue as quick input's interface is in common but Toggle is in browser and // it requires a HTMLElement on its interface const concreteToggles = this.toggles?.filter(opts => opts instanceof Toggle) as Toggle[] ?? []; this.ui.inputBox.toggles = concreteToggles; } </ins> this.ui.ignoreFocusOut = this.ignoreFocusOut; this.ui.setEnabled(this.enabled); this.ui.setContextKey(this.contextKey);


this._heartbeatSecondTimeout = undefined; if (this._isResponsive) { this._isResponsive = false; <ins> this._onPtyHostUnresponsive.fire(); </ins> } <del> this._onPtyHostUnresponsive.fire(); </del> } private _handleUnresponsiveCreateProcess() { this._clearHeartbeatTimeouts(); this._logService.error(`No ptyHost response to createProcess after ${HeartbeatConstants.CreateProcessTimeout / 1000} seconds`); <del> this._onPtyHostUnresponsive.fire(); </del> <ins> if (this._isResponsive) { this._isResponsive = false; this._onPtyHostUnresponsive.fire(); } </ins> } private _clearHeartbeatTimeouts() {


*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> import { window, Pseudoterminal, EventEmitter, TerminalDimensions, workspace, ConfigurationTarget, Disposable, UIKind, env, EnvironmentVariableMutatorType, EnvironmentVariableMutator, extensions, ExtensionContext, TerminalOptions, ExtensionTerminalOptions } from 'vscode'; import { doesNotThrow, equal, ok, deepEqual, throws } from 'assert'; </del> <ins> import { window, Pseudoterminal, EventEmitter, TerminalDimensions, workspace, ConfigurationTarget, Disposable, UIKind, env, EnvironmentVariableMutatorType, EnvironmentVariableMutator, extensions, ExtensionContext, TerminalOptions, ExtensionTerminalOptions, Terminal } from 'vscode'; import { doesNotThrow, equal, deepEqual, throws } from 'assert'; </ins> import { assertNoRpc } from '../utils'; // Disable terminal tests:


const envFromConfigValue = this._configurationService.getValue<ITerminalEnvironment | undefined>(`terminal.integrated.env.${platformKey}`); const baseEnv = await (shellLaunchConfig.useShellEnvironment ? this.getShellEnvironment() : this.getEnvironment()); const env = await terminalEnvironment.createTerminalEnvironment(shellLaunchConfig, envFromConfigValue, variableResolver, this._productService.version, this._configurationService.getValue(TerminalSettingId.DetectLocale), baseEnv); <del> if (!shellLaunchConfig.strictEnv && !shellLaunchConfig.hideFromUser) { </del> <ins> if (shouldUseEnvironmentVariableCollection(shellLaunchConfig)) { </ins> const workspaceFolder = terminalEnvironment.getWorkspaceForTerminal(shellLaunchConfig.cwd, this._workspaceContextService, this._historyService); await this._environmentVariableService.mergedCollection.applyToProcessEnvironment(env, { workspaceFolder }, variableResolver); }


} private init() { <del> const { object: notebookOutlineReference } = this.notebookOutlineReference = this.instantiationService.invokeFunction((accessor) => accessor.get(INotebookCellOutlineProviderFactory).getOrCreate(this.notebookEditor, OutlineTarget.QuickPick)); </del> <ins> const { object: notebookOutlineReference } = this.notebookOutlineReference = this.instantiationService.invokeFunction((accessor) => accessor.get(INotebookCellOutlineProviderFactory).getOrCreate(this.notebookEditor, OutlineTarget.OutlinePane)); </ins> this._register(this.notebookOutlineReference); this.updateContent(computeContent(this.notebookEditor, this.notebookCellList, notebookOutlineReference.entries, this.getCurrentStickyHeight()));


const disposables = new DisposableStore(); const rendered = disposables.add(renderMarkdown(markdown, { ...this._getRenderOptions(markdown, disposables), ...options }, markedOptions)); <ins> rendered.element.classList.add('rendered-markdown'); </ins> return { element: rendered.element, dispose: () => disposables.dispose()


if (offset + needleLength > haystackLength) { return false; } <ins> const haystackUpper = haystack.toUpperCase(); const needleUpper = needle.toUpperCase(); </ins> for (let i = 0; i < needleLength; i++) { <del> if (haystack.charCodeAt(offset + i) !== needle.charCodeAt(i)) { </del> <ins> if (haystackUpper.charCodeAt(offset + i) !== needleUpper.charCodeAt(i)) { </ins> return false; } }


let updateId = 0; hostMessaging.onMessage('content', async (_event, /** @type {ContentUpdateData} */ data) => { const currentUpdateId = ++updateId; try { await workerReady; } catch (e) {


thanks.removeClass('task-panel-hidden'); }); <del> githubLink.item(0).on('click', e => { </del> <ins> githubLink.on('click', e => { </ins> const node = event.target as HTMLAnchorElement; if (node.href) { this.openerService.open(URI.parse(node.href));


"command": "imagePreview.zoomOut", "when": "activeCustomEditorId == 'imagePreview.previewEditor'", "group": "1_imagePreview" <ins> }, { "command": "imagePreview.copyImage", "when": "false" } ], "webview/context": [ { "command": "imagePreview.copyImage", "when": "webviewId == 'imagePreview.previewEditor'" </ins> } ] }


import 'vs/css!./media/explorerviewlet'; import { localize } from 'vs/nls'; import { mark } from 'vs/base/common/performance'; <del> import { VIEWLET_ID, ExplorerViewletVisibleContext, OpenEditorsVisibleContext, VIEW_ID, IFilesConfiguration } from 'vs/workbench/contrib/files/common/files'; </del> <ins> import { VIEWLET_ID, OpenEditorsVisibleContext, VIEW_ID, IFilesConfiguration } from 'vs/workbench/contrib/files/common/files'; </ins> import { IViewletViewOptions } from 'vs/workbench/browser/parts/views/viewsViewlet'; import { IConfigurationService, IConfigurationChangeEvent } from 'vs/platform/configuration/common/configuration'; import { ExplorerView } from 'vs/workbench/contrib/files/browser/views/explorerView';


); this.acitivityBarPart = this._register(instantiationService.createInstance(ActivitybarPart, this)); <ins> this.rememberActivityBarVisiblePosition(); </ins> this._register(configurationService.onDidChangeConfiguration(e => { if (e.affectsConfiguration(LayoutSettings.ACTIVITY_BAR_LOCATION)) { <del> this.updateTitleArea(); const id = this.getActiveComposite()?.getId(); if (id) { this.onTitleAreaUpdate(id!); } this.updateActivityBarVisiblity(); </del> <ins> this.onDidChangeActivityBarLocation(); </ins> } }));


"type": "boolean", "default": true, "description": "%config.markdown.math.enabled%" <ins> }, "markdown.math.macros": { "type": "object", "additionalProperties": { "type": "string" }, "default": {}, "description": "%config.markdown.math.macros%", "scope": "resource" </ins> } } }


.pipe(replace('@@ICON@@', product.applicationName)) .pipe(rename('usr/share/applications/' + product.applicationName + '.desktop')); <ins> const desktopUrlHandler = gulp.src('resources/linux/code-url-handler.desktop', { base: '.' }) .pipe(replace('@@NAME_LONG@@', product.nameLong)) .pipe(replace('@@NAME_SHORT@@', product.nameShort)) .pipe(replace('@@NAME@@', product.applicationName)) .pipe(replace('@@ICON@@', product.applicationName)) .pipe(rename('usr/share/applications/' + product.applicationName + '-url-handler.desktop')); </ins> const appdata = gulp.src('resources/linux/code.appdata.xml', { base: '.' }) .pipe(replace('@@NAME_LONG@@', product.nameLong)) .pipe(replace('@@NAME@@', product.applicationName))


useReplacePreview: boolean; showLineNumbers: boolean; usePCRE2: boolean; <ins> actionsPosition: 'auto' | 'right'; </ins> } export interface ISearchConfiguration extends IFilesConfiguration {


dependencies: safe-buffer "^5.0.1" <ins> universalify@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.1.tgz#168efc2180964e6386d061e094df61afe239b18d" integrity sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw== </ins> util-deprecate@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf" integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8= <ins> uuid@^9.0.1: version "9.0.1" resolved "https://registry.yarnpkg.com/uuid/-/uuid-9.0.1.tgz#e188d4c8853cc722220392c424cd637f32293f30" integrity sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA== </ins> vscode-oniguruma@1.7.0: version "1.7.0" resolved "https://registry.yarnpkg.com/vscode-oniguruma/-/vscode-oniguruma-1.7.0.tgz#439bfad8fe71abd7798338d1cd3dc53a8beea94b"


import { ITerminalConfigurationService, LinuxDistro } from './terminal.js'; import type { IXtermCore } from './xterm-private.js'; import { DEFAULT_BOLD_FONT_WEIGHT, DEFAULT_FONT_WEIGHT, DEFAULT_LETTER_SPACING, DEFAULT_LINE_HEIGHT, FontWeight, ITerminalConfiguration, MAXIMUM_FONT_WEIGHT, MINIMUM_FONT_WEIGHT, MINIMUM_LETTER_SPACING, TERMINAL_CONFIG_SECTION, type ITerminalFont } from '../common/terminal.js'; <ins> import { isMacintosh } from '../../../../base/common/platform.js'; </ins> // #region TerminalConfigurationService


this.ui.checkAll.checked = this.ui.list.getAllVisibleChecked(); this.ui.visibleCount.setCount(this.ui.list.getVisibleCount()); this.ui.count.setCount(this.ui.list.getCheckedCount()); <ins> // Ensure no item is focused when using a screenreader when items update (#57501 & #166920) if (this.ui.isScreenReaderOptimized() && ariaLabel) { this._itemActivation = ItemActivation.NONE; } </ins> switch (this._itemActivation) { case ItemActivation.NONE: this._itemActivation = ItemActivation.FIRST; // only valid once, then unset


'Selection': this._register(this.menuService.createMenu(MenuId.MenubarSelectionMenu, this.contextKeyService)), 'View': this._register(this.menuService.createMenu(MenuId.MenubarViewMenu, this.contextKeyService)), 'Go': this._register(this.menuService.createMenu(MenuId.MenubarGoMenu, this.contextKeyService)), <del> 'Terminal': this._register(this.menuService.createMenu(MenuId.MenubarTerminalMenu, this.contextKeyService)), </del> 'Debug': this._register(this.menuService.createMenu(MenuId.MenubarDebugMenu, this.contextKeyService)), 'Tasks': this._register(this.menuService.createMenu(MenuId.MenubarTasksMenu, this.contextKeyService)), 'Help': this._register(this.menuService.createMenu(MenuId.MenubarHelpMenu, this.contextKeyService))


this._fixedRows = _shellLaunchConfig.attachPersistentProcess?.fixedDimensions?.rows; this._fixedCols = _shellLaunchConfig.attachPersistentProcess?.fixedDimensions?.cols; <ins> this._icon = _shellLaunchConfig.attachPersistentProcess?.icon || _shellLaunchConfig.icon; </ins> // the resource is already set when it's been moved from another window this._resource = resource || getTerminalUri(this._workspaceContextService.getWorkspace().id, this.instanceId, this.title);


const merge = require('merge-options'); const CopyWebpackPlugin = require('copy-webpack-plugin'); const { NLSBundlePlugin } = require('vscode-nls-dev/lib/webpack-bundler'); <del> const { DefinePlugin } = require('webpack'); </del> <ins> const { DefinePlugin, optimize } = require('webpack'); </ins> function withNodeDefaults(/**@type WebpackConfig*/extConfig) { /** @type WebpackConfig */


import { IEditorGroupService } from 'vs/workbench/services/group/common/groupService'; import { IMessageService } from 'vs/platform/message/common/message'; import { IWorkspaceConfigurationService } from 'vs/workbench/services/configuration/common/configuration'; <del> import { IWindowsService, IWindowService } from 'vs/platform/windows/common/windows'; </del> <ins> import { IWindowsService, IWindowService, IWindowSettings } from 'vs/platform/windows/common/windows'; </ins> import { IContextMenuService } from 'vs/platform/contextview/browser/contextView'; import { IWindowIPCService } from 'vs/workbench/services/window/electron-browser/windowService'; import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';


// rerender them. this.buttonsUpdated = true; } <ins> if (this.toggles.length) { // if there are toggles, the ui.show() clears them out of the UI so we should // rerender them. this.togglesUpdated = true; } </ins> this.update(); }


} export function getSecondaryEdits(textModel: ITextModel, positions: readonly Position[], primaryEdit: SingleTextEdit): SingleTextEdit[] { <ins> if (positions.length === 1) { // No secondary cursor positions return []; } </ins> const primaryPosition = positions[0]; const secondaryPositions = positions.slice(1); const primaryEditStartPosition = primaryEdit.range.getStartPosition();


private _cursorBlinking: TextEditorCursorBlinkingStyle; private _cursorStyle: TextEditorCursorStyle; private _cursorSmoothCaretAnimation: 'off' | 'explicit' | 'on'; <ins> private _experimentalEditContextEnabled: boolean; </ins> private _selectionIsEmpty: boolean; private _isComposingInput: boolean;


resource: vscode.Uri, previewSettings: DynamicPreviewSettings ): DynamicMarkdownPreview { <ins> const activeTextEditorURI = vscode.window.activeTextEditor?.document.uri; const scrollLine = (activeTextEditorURI?.toString() === resource.toString()) ? vscode.window.activeTextEditor?.visibleRanges[0].start.line : undefined; </ins> const preview = DynamicMarkdownPreview.create( { resource, resourceColumn: previewSettings.resourceColumn, locked: previewSettings.locked, <ins> line: scrollLine, </ins> }, previewSettings.previewColumn, this._contentProvider,


}); } <del> public acceptNextLine(editor: ICodeEditor): void { this._acceptNext(editor, (pos, text) => { </del> <ins> public async acceptNextLine(editor: ICodeEditor): Promise<void> { await this._acceptNext(editor, (pos, text) => { </ins> const m = text.match(/n/); if (m && m.index !== undefined) { return m.index + 1;


} 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; }


precondition: ContextKeyExpr.or(TerminalContextKeys.processSupported, TerminalContextKeys.terminalHasBeenCreated), keybinding: [ { <del> primary: KeyMod.Shift | KeyCode.Tab, secondary: [KeyMod.CtrlCmd | KeyCode.UpArrow, KeyMod.Alt | KeyCode.F2], </del> <ins> primary: KeyMod.Alt | KeyCode.F2, secondary: [KeyMod.CtrlCmd | KeyCode.UpArrow], </ins> weight: KeybindingWeight.WorkbenchContrib, when: ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, TerminalContextKeys.focus, ContextKeyExpr.or(terminalTabFocusModeContextKey, TerminalContextKeys.accessibleBufferFocus.negate())) }


import { Event } from 'vs/base/common/event'; const WAIT_TIME_TO_SHOW_SURVEY = 1000 * 60 * 60; // 1 hour <del> const MIN_WAIT_TIME_TO_SHOW_SURVEY = 1000 * 60 * 5; // 5 minutes </del> <ins> const MIN_WAIT_TIME_TO_SHOW_SURVEY = 1000 * 60 * 2; // 2 minutes </ins> const MAX_INSTALL_AGE = 1000 * 60 * 60 * 24; // 24 hours const REMIND_LATER_DELAY = 1000 * 60 * 60 * 4; // 4 hours const SKIP_SURVEY_KEY = 'ces/skipSurvey';


let bestDelta = 0; let bestScore = -1; // find best scored delta <del> for (let delta = -deltaBefore; delta < deltaAfter; delta++) { </del> <ins> for (let delta = -deltaBefore; delta <= deltaAfter; delta++) { </ins> const seq2OffsetStart = diff.seq2Range.start + delta; const seq2OffsetEndExclusive = diff.seq2Range.endExclusive + delta; const seq1Offset = diff.seq1Range.start + delta;


const emptyWindowsWithBackupsToRestore: IEmptyWindowBackupInfo[] = []; let filesToOpen: IFilesToOpen | undefined; <del> let emptyToOpen = 0; </del> <ins> let openOneEmptyWindow = false; </ins> // Identify things to open from open config const pathsToOpen = await this.getPathsToOpen(openConfig);


} hide() { <del> this._isExpanded = false; // Focus the container so that the comment editor will be blurred before it is hidden this.editor.focus(); </del> <ins> if (this._isExpanded) { this._isExpanded = false; // Focus the container so that the comment editor will be blurred before it is hidden this.editor.focus(); } </ins> super.hide(); }


this._register(Event.debounce(testProfiles.onDidChange, (_last, e) => e)(() => { const obj: Record</* controller id */string, /* profile id */ number[]> = {}; <del> for (const { controller, profiles } of this.testProfiles.all()) { obj[controller.id] = profiles.filter(p => p.isDefault).map(p => p.profileId); </del> <ins> for (const group of [TestRunProfileBitset.Run, TestRunProfileBitset.Debug, TestRunProfileBitset.Coverage]) { for (const profile of this.testProfiles.getGroupDefaultProfiles(group)) { obj[profile.controllerId] ??= []; obj[profile.controllerId].push(profile.profileId); } </ins> } this.proxy.$setDefaultRunProfiles(obj);


import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation'; import { ActiveEditorContext } from 'vs/workbench/common/contextkeys'; import { DiffElementViewModelBase } from 'vs/workbench/contrib/notebook/browser/diff/diffElementViewModel'; <del> import { NOTEBOOK_DIFF_CELL_INPUT, NOTEBOOK_DIFF_CELL_PROPERTY, NOTEBOOK_DIFF_CELL_PROPERTY_EXPANDED } from 'vs/workbench/contrib/notebook/browser/diff/notebookDiffEditorBrowser'; </del> <ins> import { INotebookTextDiffEditor, NOTEBOOK_DIFF_CELL_INPUT, NOTEBOOK_DIFF_CELL_PROPERTY, NOTEBOOK_DIFF_CELL_PROPERTY_EXPANDED } from 'vs/workbench/contrib/notebook/browser/diff/notebookDiffEditorBrowser'; </ins> import { NotebookTextDiffEditor } from 'vs/workbench/contrib/notebook/browser/diff/notebookDiffEditor'; import { NotebookDiffEditorInput } from 'vs/workbench/contrib/notebook/common/notebookDiffEditorInput'; <del> import { openAsTextIcon, renderOutputIcon, revertIcon } from 'vs/workbench/contrib/notebook/browser/notebookIcons'; </del> <ins> import { nextChangeIcon, openAsTextIcon, previousChangeIcon, renderOutputIcon, revertIcon } from 'vs/workbench/contrib/notebook/browser/notebookIcons'; </ins> import { IEditorService } from 'vs/workbench/services/editor/common/editorService'; import { Registry } from 'vs/platform/registry/common/platform'; import { IConfigurationRegistry, Extensions as ConfigurationExtensions } from 'vs/platform/configuration/common/configurationRegistry'; import { ICommandActionTitle } from 'vs/platform/action/common/action'; import { DEFAULT_EDITOR_ASSOCIATION } from 'vs/workbench/common/editor'; <ins> import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry'; import { KeyCode, KeyMod } from 'vs/base/common/keyCodes'; import { NOTEBOOK_DIFF_EDITOR_ID } from 'vs/workbench/contrib/notebook/common/notebookCommon'; </ins> // ActiveEditorContext.isEqualTo(SearchEditorConstants.SearchEditorID)


export class ContentHoverWidget extends ResizableContentWidget { public static ID = 'editor.contrib.resizableContentHoverWidget'; <ins> private static _lastDimensions: dom.Dimension = new dom.Dimension(0, 0); </ins> private _visibleData: ContentHoverVisibleData | undefined; private _positionPreference: ContentWidgetPositionPreference | undefined;


import { InputFocusedContext } from 'vs/platform/workbench/common/contextkeys'; import { ServicesAccessor } from 'vs/editor/browser/editorExtensions'; import { PanelFocusContext } from 'vs/workbench/browser/parts/panel/panelPart'; <ins> import { CommandsRegistry } from 'vs/platform/commands/common/commands'; import { onUnexpectedError } from 'vs/base/common/errors'; </ins> export const ADD_CONFIGURATION_ID = 'debug.addConfiguration'; export const TOGGLE_INLINE_BREAKPOINT_ID = 'editor.debug.action.toggleInlineBreakpoint'; export function registerCommands(): void { <ins> CommandsRegistry.registerCommand({ id: 'debug.startFromConfig', handler: (accessor, config: IConfig) => { const debugService = accessor.get(IDebugService); debugService.startDebugging(undefined, config).then(undefined, onUnexpectedError); } }); </ins> KeybindingsRegistry.registerCommandAndKeybindingRule({ id: 'debug.toggleBreakpoint', weight: KeybindingWeight.WorkbenchContrib + 5,


properties: { type: { type: 'string', <del> description: nls.localize('runTask.type', "The contributed task type"), enum: Array.from(this._providerTypes.values()).map(provider => provider) </del> <ins> description: nls.localize('runTask.type', "The contributed task type") </ins> }, taskName: { type: 'string', <del> description: nls.localize('runTask.taskName', "The task's label or a term to filter by"), enum: await this.tasks().then((tasks) => tasks.map(t => t._label)) </del> <ins> description: nls.localize('runTask.taskName', "The task's label or a term to filter by") </ins> } } }


private currentMediaComponent: string | undefined = undefined; private currentMediaType: string | undefined = undefined; <del> private async buildMediaComponent(stepId: string) { </del> <ins> private async buildMediaComponent(stepId: string, forceRebuild: boolean = false) { </ins> if (!this.currentWalkthrough) { throw Error('no walkthrough selected'); } const stepToExpand = assertIsDefined(this.currentWalkthrough.steps.find(step => step.id === stepId)); <del> if (this.currentMediaComponent === stepId) { return; } </del> <ins> if (!forceRebuild && this.currentMediaComponent === stepId) { return; } </ins> this.currentMediaComponent = stepId; this.stepDisposables.clear();


), })); <del> this._register(Event.runAndSubscribe(this._editors.modified.onDidChangeCursorPosition, (e) => { if (e?.reason === CursorChangeReason.Explicit) { const diff = this._diffModel.get()?.diff.get()?.mappings.find(m => m.lineRangeMapping.modified.contains(e.position.lineNumber)); if (diff?.lineRangeMapping.modified.isEmpty) { this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineDeleted, { source: 'diffEditor.cursorPositionChanged' }); } else if (diff?.lineRangeMapping.original.isEmpty) { this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineInserted, { source: 'diffEditor.cursorPositionChanged' }); } else if (diff) { this._accessibilitySignalService.playSignal(AccessibilitySignal.diffLineModified, { source: 'diffEditor.cursorPositionChanged' }); } } })); </del> <ins> this._register(Event.runAndSubscribe(this._editors.modified.onDidChangeCursorPosition, e => this._handleCursorPositionChange(e, true))); this._register(Event.runAndSubscribe(this._editors.original.onDidChangeCursorPosition, e => this._handleCursorPositionChange(e, false))); </ins> const isInitializingDiff = this._diffModel.map(this, (m, reader) => { /** @isInitializingDiff isDiffUpToDate */


detachInstance() { if (!this._isShuttingDown) { this._terminalInstance?.detachFromElement(); <ins> this._terminalInstance?.setParentContextKeyService(this._contextKeyService); </ins> this._isDetached = true; } }


import { memoize } from 'vs/base/common/decorators'; import { StopWatch } from 'vs/base/common/stopwatch'; import { IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService'; <ins> import { shouldUseEnvironmentVariableCollection } from 'vs/platform/terminal/common/terminalEnvironment'; </ins> export class LocalTerminalBackendContribution implements IWorkbenchContribution {


return TriggerAction.NO_ACTION; }, <del> accept: (keyMods, event) => this.openAnything(resourceOrEditor, { keyMods, range: this.pickState.lastRange, preserveFocus: event.inBackground }) </del> <ins> accept: (keyMods, event) => this.openAnything(resourceOrEditor, { keyMods, range: this.pickState.lastRange, preserveFocus: event.inBackground, forcePinned: event.inBackground }) </ins> }; } <del> private async openAnything(resourceOrEditor: URI | IEditorInput | IResourceEditorInput, options: { keyMods?: IKeyMods, preserveFocus?: boolean, range?: IRange, forceOpenSideBySide?: boolean }): Promise<void> { </del> <ins> private async openAnything(resourceOrEditor: URI | IEditorInput | IResourceEditorInput, options: { keyMods?: IKeyMods, preserveFocus?: boolean, range?: IRange, forceOpenSideBySide?: boolean, forcePinned?: boolean }): Promise<void> { </ins> const editorOptions: ITextEditorOptions = { preserveFocus: options.preserveFocus, <del> pinned: options.keyMods?.alt || this.configuration.openEditorPinned, </del> <ins> pinned: options.keyMods?.alt || options.forcePinned || this.configuration.openEditorPinned, </ins> selection: options.range ? Range.collapseToStart(options.range) : undefined };


} }); <ins> test('should ignore when everything excluded', () => { assert.deepStrictEqual(watcher.testNormalizePaths(['/foo/bar', '/bar'], ['**', 'something']), []); }); </ins> test('excludes are converted to absolute paths', () => { // undefined / empty


import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; import { EditorOption } from 'vs/editor/common/config/editorOptions'; import { registerThemingParticipant, IColorTheme, ICssStyleCollector } from 'vs/platform/theme/common/themeService'; <del> import { editorLightBulbForeground, editorLightBulbAutoFixForeground } from 'vs/platform/theme/common/colorRegistry'; </del> <ins> import { editorLightBulbForeground, editorLightBulbAutoFixForeground, editorBackground } from 'vs/platform/theme/common/colorRegistry'; </ins> import { Gesture } from 'vs/base/browser/touch'; import type { CodeActionTrigger } from 'vs/editor/contrib/codeAction/types'; import { Codicon } from 'vs/base/common/codicons';


} } <ins> public preparePathForTerminalAsync(path: string): Promise<string> { return new Promise<string>(c => { const hasSpace = path.indexOf(' ') !== -1; if (platform.isWindows) { const exe = this.shellLaunchConfig.executable; // 17063 is the build number where wsl path was introduced. // Update Windows uriPath to be executed in WSL. if (((exe.indexOf('wsl') !== -1) || ((exe.indexOf('bash.exe') !== -1) && (exe.indexOf('git') === -1))) && (TerminalInstance.getWindowsBuildNumber() >= 17063)) { execFile('bash.exe', ['-c', 'echo $(wslpath ' + this._escapeNonWindowsPath(path) + ')'], {}, (error, stdout, stderr) => { c(this._escapeNonWindowsPath(stdout.trim())); }); } else if (hasSpace) { c('"' + path + '"'); } } else if (!platform.isWindows) { c(this._escapeNonWindowsPath(path)); } }); } private _escapeNonWindowsPath(path: string): string { let newPath = path; if (newPath.indexOf('') !== 0) { newPath = newPath.replace(//g, ''); } if (!newPath && (newPath.indexOf('"') !== -1)) { newPath = ''' + newPath + '''; } else if (newPath.indexOf(' ') !== -1) { newPath = newPath.replace(/ /g, ' '); } return newPath; } public static getWindowsBuildNumber(): number { const osVersion = (/(d+).(d+).(d+)/g).exec(os.release()); let buildNumber: number = 0; if (osVersion && osVersion.length === 4) { buildNumber = parseInt(osVersion[3]); } return buildNumber; } </ins> public setVisible(visible: boolean): void { this._isVisible = visible; if (this._wrapperElement) {


this._configHelper.mergeDefaultShellPathAndArgs(shell); } this._initialCwd = this._getCwd(this._shellLaunchConfig, this._historyService.getLastActiveWorkspaceRoot()); <del> const env = TerminalInstance.createTerminalEnv(process.env, shell, this._initialCwd, locale, this._cols, this._rows); </del> <ins> const platformKey = platform.isWindows ? 'windows' : platform.isMacintosh ? 'osx' : 'linux'; const envFromConfig = { ...process.env, ...this._configHelper.config.env[platformKey] }; const env = TerminalInstance.createTerminalEnv(envFromConfig, shell, this._initialCwd, locale, this._cols, this._rows); </ins> this._title = shell.name || ''; this._process = cp.fork(Uri.parse(require.toUrl('bootstrap')).fsPath, ['--type=terminal'], { env,


// }); suite('hideFromUser', () => { <del> test('should be available to terminals API', done => { </del> <ins> test('should be available to terminals API', async () => { </ins> const terminal = window.createTerminal({ name: 'bg', hideFromUser: true }); <del> disposables.push(window.onDidOpenTerminal(t => { try { equal(t, terminal); equal(t.name, 'bg'); ok(window.terminals.indexOf(terminal) !== -1); } catch (e) { done(e); return; } disposables.push(window.onDidCloseTerminal(() => { // reg3.dispose(); done(); </del> <ins> const result = await new Promise<Terminal>(r => { disposables.push(window.onDidOpenTerminal(t => { if (t === terminal) { r(t); } })); }); equal(result, terminal); equal(true, window.terminals.indexOf(terminal) !== -1); await new Promise<void>(r => { disposables.push(window.onDidCloseTerminal(t => { if (t === terminal) { r(); } </ins> })); terminal.dispose(); <del> })); </del> <ins> }); </ins> }); });


import { PICK_WORKSPACE_FOLDER_COMMAND_ID } from 'vs/workbench/browser/actions/workspaceCommands'; import { INotificationService } from 'vs/platform/notification/common/notification'; import { TERMINAL_COMMAND_ID } from 'vs/workbench/parts/terminal/common/terminalCommands'; <del> import { isWindows } from 'vs/base/common/platform'; </del> import { Command } from 'vs/editor/browser/editorExtensions'; import { timeout } from 'vs/base/common/async'; import { FindReplaceState } from 'vs/editor/contrib/find/findState';


@IWorkbenchEditorService private editorService: IWorkbenchEditorService, @IEditorGroupService private editorGroupService: IEditorGroupService, @IPartService private partService: IPartService, <del> @IStorageService private storageServise: IStorageService, </del> <ins> @IStorageService private storageService: IStorageService, </ins> @IContextKeyService private contextKeyService: IContextKeyService, @IExtensionService private extensionService: IExtensionService, @IInstantiationService private instantiationService: IInstantiationService,


const range = match.range(); const matchText = match.text().substr(0, range.endColumn + 150); if (replace) { <del> return nls.localize('replacePreviewResultAria', "Replace '{0}' with '{1}' at column {2} in line {3}", matchString, match.replaceString, range.startColumn + 1, matchText); </del> <ins> return nls.localize('replacePreviewResultAria', "Replace '{0}' with '{1}' in line '{2}' at column {3}", matchString, match.replaceString, matchText, range.startColumn + 1); </ins> } <del> return nls.localize('searchResultAria', "Found '{0}' at column {1} in line '{2}'", matchString, range.startColumn + 1, matchText); </del> <ins> return nls.localize('searchResultAria', "Found '{0}' in line '{1}' at column {2}", matchString, matchText, range.startColumn + 1); </ins> } return null; }


menu: { id: MenuId.MenubarAppearanceMenu, group: '4_editor', <del> order: 4 </del> <ins> order: 5 </ins> } }); }


getAnchor: () => this._editorContainer, render: (container) => { return this._render(provider, container); <del> }, onHide: () => { provider.onClose(); this._keyListener?.dispose(); </del> } }; this._contextViewService.showContextView(delegate);


const result = { primary, secondary, menu }; createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result, 'inline'); if (i === 0) { <del> for (const action of result.primary) { allowedPrimary.set(action.id, action); } for (const action of result.secondary) { allowedSecondary.set(action.id, action); } </del> <ins> primaryGroups = this.createGroups(result.primary); secondaryGroups = this.createGroups(result.secondary); </ins> } else { <del> const primaryKeys = allowedPrimary.keys(); for (const key of primaryKeys) { if (!result.primary.some(action => action.id === key)) { allowedPrimary.delete(key); } } const secondaryKeys = allowedSecondary.keys(); for (const key of secondaryKeys) { if (!result.secondary.some(action => action.id === key)) { allowedSecondary.delete(key); } } </del> <ins> this.filterNonUniversalActions(primaryGroups, result.primary); this.filterNonUniversalActions(secondaryGroups, result.secondary); </ins> } if (listen && elements.length === 1) { listen.add(menu.onDidChange(() => this._onDidChange.fire(element)));


this._instance.focus(); this._instance.sendText(text, false); })); <ins> this.add(this._instance.onWillPaste(() => addon.isPasting = true)); this.add(this._instance.onDidPaste(() => { // Delay this slightly as synchronizing the prompt input is debounced setTimeout(() => addon.isPasting = false, 100); })); </ins> // If completions are requested, pause and queue input events until completions are // received. This fixing some problems in PowerShell, particularly enter not executing


return symbolPicks; } <del> private async openSymbol(provider: IWorkspaceSymbolProvider, symbol: IWorkspaceSymbol, token: CancellationToken, options: { keyMods: IKeyMods, forceOpenSideBySide?: boolean, preserveFocus?: boolean }): Promise<void> { </del> <ins> private async openSymbol(provider: IWorkspaceSymbolProvider, symbol: IWorkspaceSymbol, token: CancellationToken, options: { keyMods: IKeyMods, forceOpenSideBySide?: boolean, preserveFocus?: boolean, forcePinned?: boolean }): Promise<void> { </ins> // Resolve actual symbol to open for providers that can resolve let symbolToOpen = symbol;


templateData.value.appendChild(result); templateData.value.classList.add((element.severity === severity.Warning) ? 'warn' : (element.severity === severity.Error) ? 'error' : (element.severity === severity.Ignore) ? 'ignore' : 'info'); <del> templateData.source.textContent = element.sourceData ? `${element.sourceData.source.name}:${element.sourceData.lineNumber}` : ''; </del> <ins> templateData.source.textContent = element.sourceData ? `${basename(element.sourceData.source.name)}:${element.sourceData.lineNumber}` : ''; </ins> templateData.source.title = element.sourceData ? `${this.labelService.getUriLabel(element.sourceData.source.uri)}:${element.sourceData.lineNumber}` : ''; templateData.getReplElementSource = () => element.sourceData; }


border-radius: 6px; } <del> .monaco-dialog-box .dialog-message-row .dialog-message-container { padding-left: 0px; } </del> .monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-text { font-size: 25px; <del> width: max-content; } .monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-body .dialog-message { display: flex; padding: 20px; min-height: auto; color: var(--vscode-descriptionForeground); border-radius: 6px; overflow: hidden; margin-bottom: 12px; background: var(--vscode-welcomePage-tileHoverBackground); align-items: center; } .monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-body>.dialog-message { grid-area: title; align-self: flex-end; } .monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-body .dialog-message hr { border-color: var(--vscode-descriptionForeground); margin-bottom: 12px; border-width: thin; </del> <ins> min-width: max-content; </ins> } <del> .monaco-dialog-box .dialog-message-row .dialog-message-container .dialog-message-body .dialog-message .icon-widget { </del> <ins> #monaco-dialog-message-body > div > p > .codicon[class*='codicon-']::before{ </ins> padding-right: 8px; max-width: 30px; max-height: 30px;


} this._currentCommand.commandStartX = this._terminal.buffer.active.cursorX; this._currentCommand.commandStartMarker = options?.marker || this._terminal.registerMarker(0); <ins> // Clear executed as it must happen after command start this._currentCommand.commandExecutedMarker?.dispose(); this._currentCommand.commandExecutedMarker = undefined; this._currentCommand.commandExecutedX = undefined; for (const m of this._commandMarkers) { m.dispose(); } this._commandMarkers.length = 0; </ins> this._onCommandStarted.fire({ marker: options?.marker || this._currentCommand.commandStartMarker, markProperties: options?.markProperties } as ITerminalCommand); this._logService.debug('CommandDetectionCapability#handleCommandStart', this._currentCommand.commandStartX, this._currentCommand.commandStartMarker?.line); }


<meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src data: ${cspSource}; media-src ${cspSource}; script-src 'nonce-${nonce}'; style-src ${cspSource} 'nonce-${nonce}';"> <meta id="settings" data-settings="${escapeAttribute(JSON.stringify(settings))}">

${vscode.l10n.t("An error occurred while loading the audio file.")}


private _updateActionFromKernelInfo(info: INotebookKernelMatchResult): void { this._kernelDisposable.clear(); this._action.enabled = true; <del> const selectedOrSuggested = info.selected ?? ((info.all.length === 1 && info.suggestions.length === 1 && info.suggestions[0].type === NotebookKernelType.Resolved) ? info.suggestions[0] : undefined); </del> <ins> const selectedOrSuggested = info.selected ?? ((info.suggestions.length === 1 && info.suggestions[0].type === NotebookKernelType.Resolved) ? info.suggestions[0] : undefined); </ins> if (selectedOrSuggested) { // selected or suggested kernel this._action.label = selectedOrSuggested.label;


} }; <ins> if (platform.isWindows) { properties['window.autoDetectHighContrast'] = { 'type': 'boolean', 'default': true, 'description': nls.localize('autoDetectHighContrast', "If enabled, will automatically change to high contrast theme if Windows is using a high contrast theme, and to dark theme when switching away from a Windows high contrast theme."), }; } </ins> if (platform.isMacintosh) { properties['window.titleBarStyle'] = { 'type': 'string',


import { LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle'; import { launchSchemaId } from 'vs/workbench/services/configuration/common/configuration'; import { LoadedScriptsView } from 'vs/workbench/contrib/debug/browser/loadedScriptsView'; <del> import { RunToCursorAction } from 'vs/workbench/contrib/debug/browser/debugEditorActions'; </del> <ins> import { RunToCursorAction, SelectionToReplAction, SelectionToWatchExpressionsAction } from 'vs/workbench/contrib/debug/browser/debugEditorActions'; </ins> import { WatchExpressionsView, ADD_WATCH_LABEL, REMOVE_WATCH_EXPRESSIONS_COMMAND_ID, REMOVE_WATCH_EXPRESSIONS_LABEL, ADD_WATCH_ID } from 'vs/workbench/contrib/debug/browser/watchExpressionsView'; import { VariablesView, SET_VARIABLE_ID, COPY_VALUE_ID, BREAK_WHEN_VALUE_CHANGES_ID, COPY_EVALUATE_PATH_ID, ADD_TO_WATCH_ID, BREAK_WHEN_VALUE_IS_ACCESSED_ID, BREAK_WHEN_VALUE_IS_READ_ID, VIEW_MEMORY_ID } from 'vs/workbench/contrib/debug/browser/variablesView'; import { Repl } from 'vs/workbench/contrib/debug/browser/repl';