if (colorPickerWidget === undefined) { return; } <del> this.body.classList.add('standalone-colorpicker-body'); this.body.style.maxHeight = Math.max(this._editor.getLayoutInfo().height / 4, 250) + 'px'; this.body.style.maxWidth = Math.max(this._editor.getLayoutInfo().width * 0.66, 500) + 'px'; this.body.tabIndex = 0; this.body.appendChild(fragment); </del> <ins> this._body.classList.add('standalone-colorpicker-body'); this._body.style.maxHeight = Math.max(this._editor.getLayoutInfo().height / 4, 250) + 'px'; this._body.style.maxWidth = Math.max(this._editor.getLayoutInfo().width * 0.66, 500) + 'px'; this._body.tabIndex = 0; this._body.appendChild(fragment); </ins> colorPickerWidget.layout(); const colorPickerBody = colorPickerWidget.body;


IFS=' ' fi builtin read -ra ADDR <<<"$__vsc_original_prompt_command" <del> for ((i = 0; i < ${#ADDR[@]}; i++)); do builtin eval ${ADDR[i]} done </del> if [[ ${__vsc_original_ifs+set} ]]; then IFS="$__vsc_original_ifs" unset __vsc_original_ifs else unset IFS fi <ins> for ((i = 0; i < ${#ADDR[@]}; i++)); do # unset IFS builtin eval ${ADDR[i]} done </ins> __vsc_precmd }


const filteredEdits = allCellEdits.filter(edit => edit !== undefined) as ResourceEdit[]; await this.bulkEditService.apply(filteredEdits, { label: localize('insertFinalNewLine', "Insert Final New Line"), code: 'undoredo.insertFinalNewLine' }); <ins> // set cursor back to initial position after inserting final new line if (activeCellEditor && selections) { activeCellEditor.setSelections(selections); } </ins> } finally { progress.report({ increment: 100 }); disposable.dispose();


} this._beginReconnecting(); })); <del> this._register(protocol.onSocketTimeout(() => { </del> <ins> this._register(protocol.onSocketTimeout((e) => { </ins> const logPrefix = commonLogPrefix(this._connectionType, this.reconnectionToken, true); <del> this._options.logService.info(`${logPrefix} received socket timeout event.`); </del> <ins> this._options.logService.info(`${logPrefix} received socket timeout event (unacknowledgedMsgCount: ${e.unacknowledgedMsgCount}, timeSinceOldestUnacknowledgedMsg: ${e.timeSinceOldestUnacknowledgedMsg}, timeSinceLastReceivedSomeData: ${e.timeSinceLastReceivedSomeData}).`); </ins> this._beginReconnecting(); }));


} .monaco-workbench .simple-find-part.visible { <ins> visibility: visible; } .monaco-workbench .simple-find-part.visible-transition { </ins> top: 0; }


] }, "dependencies": { <del> "vscode-languageclient": "^8.0.1", </del> <ins> "vscode-languageclient": "^8.0.2-next.4", </ins> "vscode-nls": "^5.0.0", "vscode-uri": "^3.0.3" },


// When at a markdown file, apply existing scroll settings if (textEditor && textEditor.document && isMarkdownFile(textEditor.document)) { <del> const line = this._topmostLineMonitor.getPreviousEditorLineByUri(textEditor.document.uri); </del> <ins> const line = this._topmostLineMonitor.getPreviousStaticEditorLineByUri(textEditor.document.uri); </ins> if (line) { scrollEditorToLine(line, textEditor); }


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


return result[0].resource; }); } else if (fileExists && (tasksExistInFile || content)) { <del> if (content) { this._configurationService.updateValue('tasks', json.parse(content), target); </del> <ins> const statResource = stat?.resource; if (content && statResource) { this._configurationService.updateValue('tasks', json.parse(content), { resource: statResource }, target); </ins> } <del> return stat?.resource; </del> <ins> return statResource; </ins> } return undefined; }).then((resource) => {


this._storageListener.dispose(); } <del> $getValue<T>(shared: boolean, key: string): Promise<T | undefined> { </del> <ins> async $getValue<T>(shared: boolean, key: string): Promise<T | undefined> { </ins> if (shared) { this._sharedStorageKeysToWatch.set(key, true); } <del> try { return Promise.resolve(this._getValue<T>(shared, key)); } catch (error) { return Promise.reject(error); } </del> <ins> return this._getValue<T>(shared, key); </ins> } private _getValue<T>(shared: boolean, key: string): T | undefined { const jsonValue = this._storageService.get(key, shared ? StorageScope.GLOBAL : StorageScope.WORKSPACE); <del> if (!jsonValue) { return undefined; </del> <ins> if (jsonValue) { try { return JSON.parse(jsonValue); } catch (error) { // Do not fail this call but log it for diagnostics // https://github.com/microsoft/vscode/issues/132777 this._logService.error(`[mainThreadStorage] unexpected error parsing storage contents (key: ${key}, shared: ${shared}): ${error}`); } </ins> } <del> return JSON.parse(jsonValue); </del> <ins> return undefined; </ins> } <del> $setValue(shared: boolean, key: string, value: object): Promise<void> { let jsonValue: string; try { jsonValue = JSON.stringify(value); // Extension state is synced separately through extensions this._storageService.store(key, jsonValue, shared ? StorageScope.GLOBAL : StorageScope.WORKSPACE, StorageTarget.MACHINE); } catch (err) { return Promise.reject(err); } return Promise.resolve(undefined); </del> <ins> async $setValue(shared: boolean, key: string, value: object): Promise<void> { this._storageService.store(key, JSON.stringify(value), shared ? StorageScope.GLOBAL : StorageScope.WORKSPACE, StorageTarget.MACHINE /* Extension state is synced separately through extensions */); </ins> } $registerExtensionStorageKeysToSync(extension: IExtensionIdWithVersion, keys: string[]): void {


return []; } <del> return response.body .filter(highlight => highlight.file === file) .map(convertDocumentHighlight) .flat(); </del> <ins> return response.body.flatMap(convertDocumentHighlight); </ins> } }


*--------------------------------------------------------------------------------------------*/ import { IDragAndDropData } from 'vs/base/browser/dnd'; <del> import { createStyleSheet, Dimension, EventHelper } from 'vs/base/browser/dom'; </del> <ins> import { asCssValueWithDefault, createStyleSheet, Dimension, EventHelper } from 'vs/base/browser/dom'; </ins> import { DomEmitter } from 'vs/base/browser/event'; import { IKeyboardEvent, StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent'; import { Gesture } from 'vs/base/browser/touch';


this.replInput.layout({ width: width - 30, height: replInputHeight }); } <del> override shouldShowFilterInHeader(): boolean { return true; } </del> collapseAll(): void { this.tree.collapseAll(); }


import { EditorAccessibilityHelpContribution } from 'vs/workbench/contrib/accessibility/browser/editorAccessibilityHelp'; import { SaveAccessibilitySignalContribution } from 'vs/workbench/contrib/accessibility/browser/saveAccessibilitySignal'; import { CommentsAccessibilityHelpContribution } from 'vs/workbench/contrib/comments/browser/commentsAccessibility'; <ins> import { DiffEditorActiveAnnouncementContribution } from 'vs/workbench/contrib/accessibility/browser/openDiffEditorAnnouncement'; </ins> registerAccessibilityConfiguration(); registerSingleton(IAccessibleViewService, AccessibleViewService, InstantiationType.Delayed);


type: 'string', enum: ['on', 'auto', 'off'], enumDescriptions: [ <del> nls.localize('ttask.allowAutomaticTasks.on', "Always"), </del> <ins> nls.localize('task.allowAutomaticTasks.on', "Always"), </ins> nls.localize('task.allowAutomaticTasks.auto', "Prompt for permission for each folder"), nls.localize('task.allowAutomaticTasks.off', "Never"), ], <del> description: nls.localize('task.allowAutomaticTasks', "Enable automatic tasks in the folder."), </del> <ins> description: nls.localize('task.allowAutomaticTasks', "Enable automatic tasks in the folder - note that tasks won't run in an untrusted workspace."), </ins> default: 'auto', restricted: true },


import { getColorForSeverity } from 'vs/workbench/contrib/terminal/browser/terminalStatusList'; import { createAndFillInContextMenuActions, MenuEntryActionViewItem } from 'vs/platform/actions/browser/menuEntryActionViewItem'; import { DropdownWithPrimaryActionViewItem } from 'vs/platform/actions/browser/dropdownWithPrimaryActionViewItem'; <del> import { dispose, IDisposable, toDisposable } from 'vs/base/common/lifecycle'; </del> <ins> import { DisposableStore, dispose, IDisposable, toDisposable } from 'vs/base/common/lifecycle'; </ins> import { URI } from 'vs/base/common/uri'; import { ColorScheme } from 'vs/platform/theme/common/theme'; import { getColorClass, getUriClasses } from 'vs/workbench/contrib/terminal/browser/terminalIcon';


import { withNullAsUndefined } from 'vs/base/common/types'; import { URI } from 'vs/base/common/uri'; import { IUriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentity'; <del> import { isLinux, isNative, isWindows } from 'vs/base/common/platform'; </del> <ins> import { isLinux, isMacintosh, isNative, isWindows } from 'vs/base/common/platform'; </ins> import { ILogService } from 'vs/platform/log/common/log'; import { getProgressBarStyles } from 'vs/platform/theme/browser/defaultStyles';


// keep item in memory this._memoryService.memorize(model, this.editor.getPosition(), item); <del> const scrollState = StableEditorScrollState.capture(this.editor); </del> if (Array.isArray(item.completion.additionalTextEdits)) { <del> this.editor.executeEdits('suggestController.additionalTextEdits', item.completion.additionalTextEdits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))); </del> <ins> // sync additional edits const scrollState = StableEditorScrollState.capture(this.editor); this.editor.executeEdits( 'suggestController.additionalTextEdits.sync', item.completion.additionalTextEdits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text)) ); scrollState.restoreRelativeVerticalPositionOfCursor(this.editor); } else if (!item.isResolved) { // async additional edits let position: IPosition | undefined; const docListener = model.onDidChangeContent(e => { if (e.isFlush) { cts.cancel(); docListener.dispose(); return; } for (let change of e.changes) { const thisPosition = Range.getEndPosition(change.range); if (!position || Position.isBefore(thisPosition, position)) { position = thisPosition; } } }); let oldFlags = flags; flags |= InsertFlags.NoAfterUndoStop; let didType = false; let typeListener = this.editor.onWillType(() => { typeListener.dispose(); didType = true; if (!(oldFlags & InsertFlags.NoAfterUndoStop)) { this.editor.pushUndoStop(); } }); tasks.push(item.resolve(cts.token).then(() => { if (!item.completion.additionalTextEdits || cts.token.isCancellationRequested) { return; } if (position && item.completion.additionalTextEdits.some(edit => Position.isBefore(position!, Range.getStartPosition(edit.range)))) { return; } if (didType) { this.editor.pushUndoStop(); } this.editor.executeEdits( 'suggestController.additionalTextEdits.async', item.completion.additionalTextEdits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text)) ); if (didType || !(oldFlags & InsertFlags.NoAfterUndoStop)) { this.editor.pushUndoStop(); } }).finally(() => { docListener.dispose(); typeListener.dispose(); })); </ins> } let { insertText } = item.completion;


'type': 'string', 'enum': ['hide', 'filter'], 'enumDescriptions': [ <del> nls.localize('settingsSearchTocBehavior.hide', "Hide the Table of Contents while searching. The search results will not be grouped by category, and instead will be sorted by similarity to the query, with exact keyword matches coming first."), nls.localize('settingsSearchTocBehavior.filter', "Filter the Table of Contents to just categories that have matching settings. Clicking a category will filter the results to that category. The search results will be grouped by category."), </del> <ins> nls.localize('settingsSearchTocBehavior.hide', "Hide the Table of Contents while searching."), nls.localize('settingsSearchTocBehavior.filter', "Filter the Table of Contents to just categories that have matching settings. Clicking on a category will filter the results to that category."), </ins> ], 'description': nls.localize('settingsSearchTocBehavior', "Controls the behavior of the Settings editor Table of Contents while searching. If this setting is being changed in the Settings editor, the setting will take effect after the search query is modified."), 'default': 'filter',


"SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." ], "isOnlyProductionDependency": true, <del> "version": "102.0.5005.167" </del> <ins> "version": "102.0.5005.194" </ins> }, { "component": {


} } <del> async clearRecentlyOpened(): Promise<void> { </del> <ins> async clearRecentlyOpened(options?: { confirm?: boolean }): Promise<void> { if (options?.confirm) { const { response } = await this.dialogMainService.showMessageBox({ type: 'warning', buttons: [ localize({ key: 'clearButtonLabel', comment: ['&& denotes a mnemonic'] }, "&&Clear"), localize({ key: 'cancel', comment: ['&& denotes a mnemonic'] }, "&&Cancel") ], message: localize('confirmClearRecentsMessage', "Do you want to clear all recently opened files and workspaces?"), detail: localize('confirmClearDetail', "This action is irreversible!"), cancelId: 1 }); if (response !== 0) { return; } } </ins> await this.saveRecentlyOpened({ workspaces: [], files: [] }); app.clearRecentDocuments();


this.commentService.disposeCommentThread(this.owner, this._commentThread.threadId); } <del> public collapse(): Promise<void> { </del> <ins> public collapse() { </ins> this._commentThread.collapsibleState = languages.CommentThreadCollapsibleState.Collapsed; <del> if (this._commentThread.comments && this._commentThread.comments.length === 0) { this.deleteCommentThread(); return Promise.resolve(); } this.hide(); return Promise.resolve(); </del> } <del> public expand(): Promise<void> { </del> <ins> public expand() { </ins> this._commentThread.collapsibleState = languages.CommentThreadCollapsibleState.Expanded; <del> this.show(this.arrowPosition(this._commentThread.range), 2); return Promise.resolve(); </del> } public getGlyphPosition(): number {


"type": "number", "default": 0.3, "description": "%emmetPreferencesCssFuzzySearchMinScore%" <ins> }, "output.reverseAttributes": { "type": "boolean", "default": false, "description": "%emmetPreferencesOutputReverseAttributes%" </ins> } } },


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ import * as assert from 'assert'; import { URI, UriComponents } from 'vs/base/common/uri'; import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors'; import { SingleProxyRPCProtocol } from 'vs/workbench/api/test/common/testRPCProtocol'; import { NullLogService } from 'vs/platform/log/common/log'; import { ensureNoDisposablesAreLeakedInTestSuite } from 'vs/base/test/common/utils'; import { ExtHostDocumentContentProvider } from 'vs/workbench/api/common/extHostDocumentContentProviders'; import { Emitter } from 'vs/base/common/event'; import { MainThreadDocumentContentProvidersShape } from 'vs/workbench/api/common/extHost.protocol'; import { timeout } from 'vs/base/common/async'; import { runWithFakedTimers } from 'vs/base/test/common/timeTravelScheduler'; suite('ExtHostDocumentContentProvider', () => { ensureNoDisposablesAreLeakedInTestSuite(); const resource = URI.parse('foo:bar'); let documentContentProvider: ExtHostDocumentContentProvider; let mainThreadContentProvider: MainThreadDocumentContentProvidersShape; const changes: [uri: UriComponents, value: string][] = []; setup(() => { changes.length = 0; mainThreadContentProvider = new class implements MainThreadDocumentContentProvidersShape { $registerTextContentProvider(handle: number, scheme: string): void { } $unregisterTextContentProvider(handle: number): void { } async $onVirtualDocumentChange(uri: UriComponents, value: string): Promise<void> { await timeout(10); changes.push([uri, value]); } dispose(): void { throw new Error('Method not implemented.'); } }; const ehContext = SingleProxyRPCProtocol(mainThreadContentProvider); const documentsAndEditors = new ExtHostDocumentsAndEditors(ehContext, new NullLogService()); documentsAndEditors.$acceptDocumentsAndEditorsDelta({ addedDocuments: [{ isDirty: false, languageId: 'foo', uri: resource, versionId: 1, lines: ['foo'], EOL: 'n', }] }); documentContentProvider = new ExtHostDocumentContentProvider(ehContext, documentsAndEditors, new NullLogService()); }); test('TextDocumentContentProvider drops onDidChange events when they happen quickly #179711', async () => { await runWithFakedTimers({}, async function () { const emitter = new Emitter<URI>(); const contents = ['X', 'Y']; let counter = 0; let stack = 0; const d = documentContentProvider.registerTextDocumentContentProvider(resource.scheme, { onDidChange: emitter.event, async provideTextDocumentContent(_uri) { assert.strictEqual(stack, 0); stack++; try { await timeout(0); return contents[counter++ % contents.length]; } finally { stack--; } } }); emitter.fire(resource); emitter.fire(resource); await timeout(100); assert.strictEqual(changes.length, 2); assert.strictEqual(changes[0][1], 'X'); assert.strictEqual(changes[1][1], 'Y'); d.dispose(); }); }); }); </ins>


return null; } <ins> const result: CompletionList = { suggestions: [] }; </ins> const afterRange = new Range(position.lineNumber, range.replace.startColumn, position.lineNumber, range.replace.startColumn + '#file:'.length); <del> return { suggestions: [ { label: `${chatVariableLeader}file`, insertText: `${chatVariableLeader}file:`, detail: localize('pickFileLabel', "Pick a file"), range, kind: CompletionItemKind.Text, command: { id: SelectAndInsertFileAction.ID, title: SelectAndInsertFileAction.ID, arguments: [{ widget, range: afterRange }] }, sortText: 'z' } satisfies CompletionItem ] }; </del> <ins> result.suggestions.push({ label: `${chatVariableLeader}file`, insertText: `${chatVariableLeader}file:`, detail: localize('pickFileLabel', "Pick a file"), range, kind: CompletionItemKind.Text, command: { id: SelectAndInsertFileAction.ID, title: SelectAndInsertFileAction.ID, arguments: [{ widget, range: afterRange }] }, sortText: 'z' }); await this.addFileEntries(widget, result, range, token); return result; </ins> } })); <ins> this._register(CommandsRegistry.registerCommand(BuiltinDynamicCompletions.addReferenceCommand, (_services, arg) => this.cmdAddReference(arg))); this.queryBuilder = this.instantiationService.createInstance(QueryBuilder); } private async addFileEntries(widget: IChatWidget, result: CompletionList, info: { insert: Range; replace: Range; varWord: IWordAtPosition | null }, token: CancellationToken) { const makeFileCompletionItem = (resource: URI): CompletionItem => { const basename = this.labelService.getUriBasenameLabel(resource); const insertText = `${chatVariableLeader}file:${basename} `; return { label: { label: `${chatVariableLeader}file:${basename}`, description: this.labelService.getUriLabel(resource) }, insertText, range: info, kind: CompletionItemKind.File, sortText: 'zz', command: { id: BuiltinDynamicCompletions.addReferenceCommand, title: '', arguments: [new ReferenceArgument(widget, { id: 'vscode.file', range: { startLineNumber: info.replace.startLineNumber, startColumn: info.replace.startColumn, endLineNumber: info.replace.endLineNumber, endColumn: info.replace.startColumn + insertText.length }, data: resource })] } }; }; let pattern: string | undefined; if (info.varWord?.word && info.varWord.word.startsWith(chatVariableLeader)) { pattern = info.varWord.word.toLowerCase().slice(1); // remove leading # } const seen = new ResourceSet(); const len = result.suggestions.length; // HISTORY // always take the last N items for (const item of this.historyService.getHistory()) { if (!item.resource || !this.workspaceContextService.getWorkspaceFolder(item.resource)) { // ignore "forgein" editors continue; } if (pattern) { // use pattern if available const basename = this.labelService.getUriBasenameLabel(item.resource).toLowerCase(); if (!isPatternInWord(pattern, 0, pattern.length, basename, 0, basename.length)) { continue; } } seen.add(item.resource); const newLen = result.suggestions.push(makeFileCompletionItem(item.resource)); if (newLen - len >= 5) { break; } } // SEARCH // use file search when having a pattern if (pattern) { const query = this.queryBuilder.file(this.workspaceContextService.getWorkspace().folders, { filePattern: pattern, maxResults: 25 }); const data = await this.searchService.fileSearch(query, token); for (const match of data.results) { if (seen.has(match.resource)) { // already included via history continue; } result.suggestions.push(makeFileCompletionItem(match.resource)); } if (!data.limitHit) { result.incomplete = true; } } } private cmdAddReference(arg: ReferenceArgument) { // invoked via the completion command arg.widget.getContrib<ChatDynamicVariableModel>(ChatDynamicVariableModel.ID)?.addReference(arg.variable); </ins> } }


get providers(): Map<string, ITerminalQuickFixProvider> { return this._providers; } constructor(@ITerminalContributionService private readonly _terminalContributionService: ITerminalContributionService) { <del> for (const selector of this._terminalContributionService.quickFixes) { this.registerCommandSelector(selector); } </del> <ins> this._terminalContributionService.quickFixes.then(selectors => { for (const selector of selectors) { this.registerCommandSelector(selector); } }); </ins> } registerCommandSelector(selector: ITerminalCommandSelector): void {


} } <del> async pull(rebase?: boolean): Promise<void> { </del> <ins> async pull(rebase?: boolean, remote?: string, branch?: string): Promise<void> { </ins> const args = ['pull']; if (rebase) { args.push('-r'); } <ins> if (remote && branch) { args.push(remote); args.push(branch); } </ins> try { await this.run(args); } catch (err) {


} export class ExplorerItem { <del> private _isDirectoryResolved: boolean; </del> <ins> protected _isDirectoryResolved: boolean; </ins> private _isDisposed: boolean; public isError = false;


// this partition for shared memory. // Refs https://github.com/microsoft/vscode/issues/152143 args.push('--disable-dev-shm-usage'); <ins> // Refs https://github.com/microsoft/vscode/issues/192206 args.push('--disable-gpu'); </ins> } if (process.platform === 'darwin') {


suite('Fuzzy Scorer', () => { test('score (fuzzy)', function () { <del> const target = 'HeLlo-World'; </del> <ins> const target = 'HelLo-World'; </ins> const scores: FuzzyScore[] = []; scores.push(_doScore(target, 'HelLo-World', true)); // direct case match


const tabSize = this._context.model.getTabSize(); const tabWidth = tabSize * this._spaceWidth; const lineHeight = this._lineHeight; <del> const indentGuideWidth = dom.computeScreenAwareSize(1); </del> <ins> const indentGuideWidth = tabWidth; </ins> const indents = this._context.model.getLinesIndentGuides(visibleStartLineNumber, visibleEndLineNumber);


ctrl.insert('farboo'); assertSelections(editor, new Selection(1, 7, 1, 7), new Selection(2, 11, 2, 11)); <del> // assertContextKeys(contextKeys, true, false, true); </del> <ins> assertContextKeys(contextKeys, true, false, true); </ins> <del> // ctrl.next(); // assertSelections(editor, new Selection(1, 7, 1, 7), new Selection(2, 11, 2, 11)); </del> <ins> ctrl.next(); assertSelections(editor, new Selection(1, 7, 1, 7), new Selection(2, 11, 2, 11)); </ins> assertContextKeys(contextKeys, false, false, false); });


URL:      https://code.visualstudio.com/ Icon:     @@NAME@@.xpm Requires: glibc >= 2.15 <ins> Requires: GConf2 </ins> %ifarch x86_64 Requires: libXss.so.1()(64bit) %else


return; } <del> const options = { findNext: true, forward: !previous }; </del> <ins> const options = { findNext: false, forward: !previous }; </ins> if (!this._findStarted) { this.startFind(value, options); return;


markdownIt.linkify.set({ fuzzyLink: false }); addNamedHeaderRendering(markdownIt); <ins> addLinkRenderer(markdownIt); </ins> const style = document.createElement('style'); style.textContent = `


private _shadowElement?: HTMLElement; private _shadowElementViewInfo: { height: number; width: number; top: number; left: number } | null = null; <del> private _listStyleOverride = { listBackground: notebookEditorBackground, listActiveSelectionBackground: notebookEditorBackground, listActiveSelectionForeground: foreground, listFocusAndSelectionBackground: notebookEditorBackground, listFocusAndSelectionForeground: foreground, listFocusBackground: notebookEditorBackground, listFocusForeground: foreground, listHoverForeground: foreground, listHoverBackground: notebookEditorBackground, listHoverOutline: focusBorder, listFocusOutline: focusBorder, listInactiveSelectionBackground: notebookEditorBackground, listInactiveSelectionForeground: foreground, listInactiveFocusBackground: notebookEditorBackground, listInactiveFocusOutline: notebookEditorBackground, }; </del> private readonly _editorFocus: IContextKey<boolean>; private readonly _outputFocus: IContextKey<boolean>; private readonly _editorEditable: IContextKey<boolean>;


@ITextFileService private readonly textFileService: ITextFileService, @IStatusbarService private readonly statusbarService: IStatusbarService, @IInstantiationService private readonly instantiationService: IInstantiationService, <del> @IContextKeyService private readonly contextKeyService: IContextKeyService </del> <ins> @IContextKeyService private readonly contextKeyService: IContextKeyService, @IConfigurationService private readonly configurationService: IConfigurationService </ins> ) { super();


if (command && this._currentStickyCommand !== command) { this._throttledRefresh(); } else { <del> this._debouncedRefresh(); </del> <ins> // If it's the same command, do not throttle as the sticky scroll overlay height may // need to be adjusted. This would cause a flicker if throttled. this._refreshNow(); </ins> } } <del> @debounce(20) private _debouncedRefresh(): void { this._throttledRefresh(); } </del> @throttle(0) private _throttledRefresh(): void { <ins> this._refreshNow(); } private _refreshNow(): void { </ins> const command = this._commandDetection.getCommandForLine(this._xterm.raw.buffer.active.viewportY); // The command from viewportY + 1 is used because this one will not be obscured by sticky


import { ExplorerViewPaneContainer } from 'vs/workbench/contrib/files/browser/explorerViewlet'; import { onUnexpectedError } from 'vs/base/common/errors'; import { category, getElementsToOperateOn, getSearchView, openSearchView } from 'vs/workbench/contrib/search/browser/searchActionsBase'; <ins> import { withNullAsUndefined } from 'vs/base/common/types'; import { IConfigurationResolverService } from 'vs/workbench/services/configurationResolver/common/configurationResolver'; import { IHistoryService } from 'vs/workbench/services/history/common/history'; import { Schemas } from 'vs/base/common/network'; </ins> //#region Interfaces


export interface MainThreadDocumentContentProvidersShape extends IDisposable { $registerTextContentProvider(handle: number, scheme: string): void; $unregisterTextContentProvider(handle: number): void; <del> $onVirtualDocumentChange(uri: UriComponents, value: string): void; </del> <ins> $onVirtualDocumentChange(uri: UriComponents, value: string): Promise<void>; </ins> } export interface MainThreadDocumentsShape extends IDisposable {


document: vscode.TextDocument, webview: vscode.WebviewPanel ): Promise<void> { <del> const lineNumber = this._topmostLineMonitor.getPreviousEditorLineByUri(document.uri); </del> <ins> const lineNumber = this._topmostLineMonitor.getPreviousTextEditorLineByUri(document.uri); </ins> const preview = StaticMarkdownPreview.revive( document.uri, webview,


this.onTabFocusModeChange(); } })); <ins> this._register(this.configurationService.onDidChangeConfiguration(e => { if (e.affectsConfiguration('editor.tabFocusMode')) { TabFocus.setTabFocusMode(this.configurationService.getValue('editor.tabFocusMode'), TabFocusContext.Editor); this.onTabFocusModeChange(); } else if (e.affectsConfiguration(TerminalSettingId.TabFocusMode)) { TabFocus.setTabFocusMode(this.configurationService.getValue(TerminalSettingId.TabFocusMode), TabFocusContext.Terminal); this.onTabFocusModeChange(); } })); </ins> } private registerCommands(): void {


<del> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><defs><style>.icon-canvas-transparent,.icon-vs-out{fill:#f6f6f6;}.icon-canvas-transparent{opacity:0;}.icon-disabled-grey{fill:#848484;}</style></defs><title>breakpoint-log-unverified</title><g id="canvas"><path class="icon-canvas-transparent" d="M16,0V16H0V0Z"/></g><g id="outline" style="display: none;"><path class="icon-vs-out" d="M13.414,8,8,13.414,2.586,8,8,2.586Z"/></g><g id="iconBg"><path class="icon-disabled-grey" d="M8,4,4,8l4,4,4-4ZM5.414,8,8,5.414,10.586,8,8,10.586Z"/></g></svg> </del>  No newline at end of file <ins> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><defs><style>.icon-canvas-transparent,.icon-vs-out{fill:#f6f6f6;}.icon-canvas-transparent{opacity:0;}.icon-disabled-grey{fill:#848484;}</style></defs><title>breakpoint-log-unverified</title><g id="canvas"><path class="icon-canvas-transparent" d="M16,0V16H0V0Z"/></g><g id="outline" style="display: none;"><path class="icon-vs-out" d="M13.664,8,8,13.664,2.336,8,8,2.336Z"/></g><g id="iconBg"><path class="icon-disabled-grey" d="M8,3.75,3.75,8,8,12.25,12.25,8ZM5.518,8,8,5.518,10.482,8,8,10.482Z"/></g></svg> </ins>  No newline at end of file


isDefault: true }; if (detectedProfile && detectedProfile.profileName === createdProfile.profileName && detectedProfile.path === createdProfile.path && this._argsMatch(detectedProfile.args, createdProfile.args)) { <del> return undefined; </del> <ins> return detectedProfile.profileName; </ins> } return createdProfile; }


*/ .monaco-editor .lines-content .cigr { position: absolute; <ins> --box-shadow-color: rgba(0, 0, 0, 0); box-shadow: 1px 0 0 0 var(--box-shadow-color) inset; </ins> }


if (!alertSetting) { return; } <del> const alertSettingValue: NotificationSetting = this._configurationService.getValue(alertSetting); if (this._shouldNotify(alertSettingValue, userGesture)) { this._logService.debug('AccessibleNotificationService alerting: ', alertMessage); this._accessibilityService.alert(alertMessage); } </del> const audioCueSetting: NotificationSetting = this._configurationService.getValue(audioCue.settingsKey); if (this._shouldNotify(audioCueSetting, userGesture)) { this._logService.debug('AccessibleNotificationService playing sound: ', audioCue.name); <ins> console.log('AccessibleNotificationService playing sound: ', audioCue.name); </ins> // Play sound bypasses the usual audio cue checks IE screen reader optimized, auto, etc. this._audioCueService.playSound(audioCue.sound.getSound(), true); <ins> return; } const alertSettingValue: NotificationSetting = this._configurationService.getValue(alertSetting); if (this._shouldNotify(alertSettingValue, userGesture)) { this._logService.debug('AccessibleNotificationService alerting: ', alertMessage); console.log('AccessibleNotificationService alerting: ', alertMessage); this._accessibilityService.alert(alertMessage); </ins> } }


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


description: localize('verbosity.comments', 'Provide information about actions that can be taken in the comment widget or in a file which contains comments.'), ...baseVerbosityProperty }, <ins> [AccessibilityVerbositySettingId.DiffEditorActive]: { description: localize('verbosity.diffEditorActive', 'Indicate when a diff editor becomes the active editor.'), ...baseVerbosityProperty }, </ins> [AccessibilityAlertSettingId.Save]: { 'markdownDescription': localize('announcement.save', "Indicates when a file is saved. Also see {0}.", '`#audioCues.save#`'), 'enum': ['userGesture', 'always', 'never'],


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


this._commentsElement.focus(); } <ins> ensureFocusIntoNewEditingComment() { if (this._commentElements.length === 1 && this._commentElements[0].isEditing) { this._commentElements[0].setFocus(true); } } </ins> async display() { this._commentsElement = dom.append(this.container, dom.$('div.comments-container')); this._commentsElement.setAttribute('role', 'presentation');


accessibilitySupport: app.accessibilitySupportEnabled, colorScheme: this.themeMainService.getColorScheme(), policiesData: this.policyService.serialize(), <del> editSessionId: this.environmentMainService.editSessionId, </del> }; let window: ICodeWindow | undefined;


} } <del> public onLineMappingChanged(e: viewEvents.ViewLineMappingChangedEvent): void { </del> <ins> public updateAnchorViewPosition(): void { </ins> this._setPosition(this._affinity, this._primaryAnchor.modelPosition, this._secondaryAnchor.modelPosition); }


const verbose = this._configurationService.getValue(provider.verbositySettingKey); const hasActions = this._accessibleViewSupportsNavigation.get() || this._accessibleViewVerbosityEnabled.get() || this._accessibleViewGoToSymbolSupported.get() || this._currentProvider?.actions; if (verbose && !showAccessibleViewHelp && hasActions) { <del> actionsHint = localize('ariaAccessibleViewActions', "Use Shift+Tab to explore actions such as disabling this hint."); </del> <ins> actionsHint = localize('ariaAccessibleViewActions', 'Explore actions such as disabling this hint (Shift+Tab).'); </ins> } let ariaLabel = provider.options.type === AccessibleViewType.Help ? localize('accessibility-help', "Accessibility Help") : localize('accessible-view', "Accessible View"); this._title.textContent = ariaLabel;


cellEditorOptionsCustomizations: 'notebook.editorOptionsCustomizations', consolidatedRunButton: 'notebook.consolidatedRunButton', openGettingStarted: 'notebook.experimental.openGettingStarted', <del> textOutputLineLimit: 'notebook.output.textLineLimit', </del> globalToolbarShowLabel: 'notebook.globalToolbarShowLabel', markupFontSize: 'notebook.markup.fontSize', interactiveWindowCollapseCodeCells: 'interactiveWindow.collapseCellInputCode', <del> outputLineHeight: 'notebook.outputLineHeight', outputFontSize: 'notebook.outputFontSize', outputFontFamily: 'notebook.outputFontFamily', </del> kernelPickerType: 'notebook.kernelPicker.type', outputScrolling: 'notebook.experimental.outputScrolling', <ins> textOutputLineLimit: 'notebook.output.textLineLimit', </ins> outputWordWrap: 'notebook.output.wordWrap', <ins> outputLineHeightDeprecated: 'notebook.outputLineHeight', outputLineHeight: 'notebook.output.lineHeight', outputFontSizeDeprecated: 'notebook.outputFontSize', outputFontSize: 'notebook.output.fontSize', outputFontFamilyDeprecated: 'notebook.outputFontFamily', outputFontFamily: 'notebook.output.fontFamily', </ins> logging: 'notebook.logging', } as const;


} const tunnelArgs = argv.slice(argv.indexOf('tunnel') + 1); // all arguments behind `tunnel` return new Promise((resolve, reject) => { <del> let tunnelProcess: ChildProcessWithoutNullStreams; </del> <ins> let tunnelProcess: ChildProcess; const stdio: StdioOptions = ['ignore', 'pipe', 'pipe']; </ins> if (process.env['VSCODE_DEV']) { <del> tunnelProcess = spawn('cargo', ['run', '--', 'tunnel', ...tunnelArgs], { cwd: join(getAppRoot(), 'cli') }); </del> <ins> tunnelProcess = spawn('cargo', ['run', '--', 'tunnel', ...tunnelArgs], { cwd: join(getAppRoot(), 'cli'), stdio }); </ins> } else { const appPath = process.platform === 'darwin' // ./Contents/MacOS/Electron => ./Contents/Resources/app/bin/code-tunnel-insiders ? join(dirname(dirname(process.execPath)), 'Resources', 'app') : dirname(process.execPath); const tunnelCommand = join(appPath, 'bin', `${product.tunnelApplicationName}${isWindows ? '.exe' : ''}`); <del> tunnelProcess = spawn(tunnelCommand, ['tunnel', ...tunnelArgs], { cwd: cwd() }); </del> <ins> tunnelProcess = spawn(tunnelCommand, ['tunnel', ...tunnelArgs], { cwd: cwd(), stdio }); </ins> } <del> tunnelProcess.stdout.pipe(process.stdout); tunnelProcess.stderr.pipe(process.stderr); </del> <ins> tunnelProcess.stdout!.pipe(process.stdout); tunnelProcess.stderr!.pipe(process.stderr); </ins> tunnelProcess.on('exit', resolve); tunnelProcess.on('error', reject); });


updateStyleOverrides(overrideStyles?: IColorMapping): void { dispose(this.styler); <del> this.styler = overrideStyles ? attachListStyler(this.tree, this.themeService, overrideStyles) : Disposable.None; </del> <ins> this.styler = attachListStyler(this.tree, this.themeService, overrideStyles); </ins> } dispose(): void {


private registerListeners(): void { this.editorGroupService.whenReady.then(() => { this.updateEditorAreaContextKeys(); <ins> this.updateEditorGroupContextKeys(); this.updateVisiblePanesContextKeys(); </ins> }); <ins> this._register(this.editorService.onDidActiveEditorChange(() => this.updateEditorGroupContextKeys())); this._register(this.editorService.onDidVisibleEditorsChange(() => this.updateVisiblePanesContextKeys())); this._register(this.editorGroupService.onDidAddGroup(() => this.updateEditorGroupContextKeys())); this._register(this.editorGroupService.onDidRemoveGroup(() => this.updateEditorGroupContextKeys())); this._register(this.editorGroupService.onDidChangeGroupIndex(() => this.updateEditorGroupContextKeys())); this._register(this.editorGroupService.onDidChangeActiveGroup(() => this.updateEditorGroupsContextKeys())); this._register(this.editorGroupService.onDidChangeGroupLocked(() => this.updateEditorGroupsContextKeys())); </ins> this._register(this.editorGroupService.onDidChangeEditorPartOptions(() => this.updateEditorAreaContextKeys())); this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => disposables.add(addDisposableListener(window, EventType.FOCUS_IN, () => this.updateInputContextKeys(window.document), true)), { window: mainWindow, disposables: this._store }));


test('issue #62278: "Ctrl + click to follow link" for IPv6 URLs', () => { assertLink( 'let x = "http://[::1]:5000/connect/token"', <del> '         http://[::1]:5000/connect/token ' </del> <ins> '         http://[::1]:5000/connect/token  ' </ins> ); });


.pipe(replace('@@LICENSE@@', product.licenseName)) .pipe(rename('usr/share/appdata/' + product.applicationName + '.appdata.xml')); <ins> const workspaceMime = gulp.src('resources/code-workspace.xml', { base: '.' }) .pipe(replace('@@NAME_LONG@@', product.nameLong)) .pipe(replace('@@NAME@@', product.applicationName)) .pipe(rename('BUILD/usr/share/mime/packages/' + product.applicationName + '-workspace.xml')); </ins> const icon = gulp.src('resources/linux/code.png', { base: '.' }) .pipe(rename('BUILD/usr/share/pixmaps/' + product.linuxIconName + '.png'));


*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <ins> import { addDisposableListener, h, EventType } from 'vs/base/browser/dom'; import { renderIcon } from 'vs/base/browser/ui/iconLabel/iconLabels'; import { Codicon } from 'vs/base/common/codicons'; </ins> import { Disposable, toDisposable } from 'vs/base/common/lifecycle'; import { IObservable, autorunWithStore, derived } from 'vs/base/common/observable'; import { IGlyphMarginWidget, IGlyphMarginWidgetPosition } from 'vs/editor/browser/editorBrowser';


<ins> // from https://flutter.dev/ import 'package:flutter/material.dart'; void main() async { runApp( MaterialApp( debugShowCheckedModeBanner: false, home: Scaffold( body: MyApp(), ), ), ); } class MyApp extends StatefulWidget { @override _MyAppState createState() => _MyAppState(); } </ins>  No newline at end of file


deepStrictEqual(actualLinks, expectedLinks); } <ins> function countOccurrences(source: string, pattern: string): number { return source.length - (source.replaceAll(pattern, '').length / pattern.length); } </ins> export async function resolveLinkForTest(link: string, uri?: URI): Promise<ResolvedLink> { <ins> // A set of conditions to help with square brackets in testing, this is only needed because the // resolve path function must be injected if (link.startsWith('[')) { return null; } if (countOccurrences(link, '[') !== countOccurrences(link, ']')) { return null; } if (link.includes('[') !== link.includes(']')) { return null; } </ins> return { link, uri: URI.from({ scheme: Schemas.file, path: link }),


} private async getProfileToImport(profileTemplate: IUserDataProfileTemplate, temp?: boolean): Promise<IUserDataProfile | undefined> { <del> const profile = this.userDataProfilesService.profiles.find(p => p.name === profileTemplate.name); </del> <ins> const profileName = temp ? `${profileTemplate.name} (${localize('preview', "Preview")})` : profileTemplate.name; const profile = this.userDataProfilesService.profiles.find(p => p.name === profileName); </ins> if (profile) { if (temp) { <del> return this.userDataProfilesService.createNamedProfile(`${profileTemplate.name} ${this.getProfileNameIndex(profileTemplate.name)}`, { shortName: profileTemplate.shortName, transient: temp }); </del> <ins> return this.userDataProfilesService.createNamedProfile(`${profileName} ${this.getProfileNameIndex(profileName)}`, { shortName: profileTemplate.shortName, transient: temp }); </ins> } enum ImportProfileChoice {


"@vscode/iconv-lite-umd": "0.7.0", "@vscode/proxy-agent": "^0.18.2", "@vscode/ripgrep": "^1.15.9", <del> "@vscode/spdlog": "^0.13.12", </del> <ins> "@vscode/spdlog": "^0.14.0", </ins> "@vscode/vscode-languagedetection": "1.0.21", "@vscode/windows-process-tree": "^0.5.0", "@vscode/windows-registry": "^1.1.0",


const debugIconDisconnectColor = theme.getColor(debugIconDisconnectForeground); if (debugIconDisconnectColor) { <del> collector.addRule(`.monaco-workbench .part > .title > .title-actions .action-label${ThemeIcon.asCSSSelector(icons.debugDisconnect)},.monaco-workbench ${ThemeIcon.asCSSSelector(icons.debugDisconnect)} { color: ${debugIconDisconnectColor}; }`); </del> <ins> collector.addRule(`.monaco-workbench .part > .title > .title-actions .action-label${ThemeIcon.asCSSSelector(icons.debugDisconnect)},.monaco-workbench .debug-view-content ${ThemeIcon.asCSSSelector(icons.debugDisconnect)}, .monaco-workbench .debug-toolbar ${ThemeIcon.asCSSSelector(icons.debugDisconnect)}, .monaco-workbench .command-center-center ${ThemeIcon.asCSSSelector(icons.debugDisconnect)} { color: ${debugIconDisconnectColor}; }`); </ins> } const debugIconRestartColor = theme.getColor(debugIconRestartForeground);


id: RunToCursorAction.ID, label: RunToCursorAction.LABEL, alias: 'Debug: Run to Cursor', <del> precondition: ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, PanelFocusContext.toNegated(), EditorContextKeys.editorTextFocus), </del> <ins> precondition: ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, PanelFocusContext.toNegated(), CONTEXT_DEBUG_STATE.isEqualTo('stopped'), EditorContextKeys.editorTextFocus), </ins> contextMenuOpts: { group: 'debug', order: 2


private readonly _domNode: HTMLElement; private readonly _pickedColorNode: HTMLElement; <ins> private readonly _pickedColorPresentation: HTMLElement; </ins> private readonly _originalColorNode: HTMLElement; private readonly _closeButton: CloseButton | null = null; private backgroundColor: Color;


public readonly range: Range, public readonly initialMousePosX: number | undefined, public readonly initialMousePosY: number | undefined, <ins> public readonly supportsMarkerHover: boolean | undefined </ins> ) { } public equals(other: HoverAnchor) {


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


public readonly resultCodeEditorView: ResultCodeEditorView, public readonly baseCodeEditorView: IObservable<BaseCodeEditorView | undefined>, public readonly showNonConflictingChanges: IObservable<boolean>, <del> @IConfigurationService public readonly configurationService: IConfigurationService, </del> <ins> @IConfigurationService private readonly configurationService: IConfigurationService, @INotificationService private readonly notificationService: INotificationService </ins> ) { super();


this._sourceControl.commitTemplate = commitTemplate; // Execute cancellable long-running operations <del> const config = workspace.getConfiguration('git'); let sort = config.get<'alphabetically' | 'committerdate'>('branchSortOrder') || 'alphabetically'; if (sort !== 'alphabetically' && sort !== 'committerdate') { sort = 'alphabetically'; } </del> const [resourceGroups, refs] = await Promise.all([ this.getStatus(cancellationToken), <del> this.repository.getRefs({ sort }, cancellationToken)]); </del> <ins> this.getRefs({}, cancellationToken)]); </ins> this._refs = refs!; this._updateResourceGroupsState(resourceGroups);


override updateOptions(options: IWorkbenchListOptionsUpdate): void { super.updateOptions(options); <del> if (options.overrideStyles) { </del> <ins> if (options.overrideStyles !== undefined) { </ins> this.updateStyles(options.overrideStyles); }


export class CommandsConverter implements extHostTypeConverter.Command.ICommandsConverter { <del> readonly delegatingCommandId: string = `__vsc${Date.now().toString(36)} `; </del> <ins> readonly delegatingCommandId: string = `__vsc${generateUuid()}`; </ins> private readonly _cache = new Map<string, vscode.Command>(); private _cachIdPool = 0;


if (!_singleSlashStart.test(ret.path)) { throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash ("/") character'); } <del> } else { if (_doubleSlashStart.test(ret.path)) { throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")'); } </del> <ins> } else if (_doubleSlashStart.test(ret.path)) { throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")'); </ins> } } }


} .monaco-workbench .simple-find-part { <ins> visibility: hidden;		/* Use visibility to maintain flex layout while hidden otherwise interferes with transition */ </ins> z-index: 10; position: relative; top: -45px;


}, { "name": "counter-increment", <del> "desc": "Counters are used with the 'counter()' and 'counters()' functions of the the 'content' property.", </del> <ins> "desc": "Counters are used with the 'counter()' and 'counters()' functions of the 'content' property.", </ins> "browsers": "C,FF1.5,IE8,O10.5,S3", "restriction": "identifier, integer", "values": []


registerWorkbenchContribution2(AccessibilityStatus.ID, AccessibilityStatus, WorkbenchPhase.BlockRestore); registerWorkbenchContribution2(SaveAccessibilitySignalContribution.ID, SaveAccessibilitySignalContribution, WorkbenchPhase.AfterRestored); <ins> registerWorkbenchContribution2(DiffEditorActiveAnnouncementContribution.ID, DiffEditorActiveAnnouncementContribution, WorkbenchPhase.AfterRestored); </ins> registerWorkbenchContribution2(DynamicSpeechAccessibilityConfiguration.ID, DynamicSpeechAccessibilityConfiguration, WorkbenchPhase.AfterRestored);


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


if (resolveResult && resolveResult.enterChord) { shouldPreventDefault = true; this._enterChordMode(firstPart, keypressLabel); <ins> this._log(`+ Entering chord mode...`); </ins> return shouldPreventDefault; } if (this._currentChord) { if (!resolveResult || !resolveResult.commandId) { <ins> this._log(`+ Leaving chord mode: Nothing bound to "${this._currentChord.label} ${keypressLabel}".`); </ins> this._notificationService.status(nls.localize('missing.chord', "The key combination ({0}, {1}) is not a command.", this._currentChord.label, keypressLabel), { hideAfter: 10 * 1000 /* 10s */ }); shouldPreventDefault = true; }


"cssnano": "^4.1.11", "debounce": "^1.0.0", "deemon": "^1.8.0", <del> "electron": "25.8.1", </del> <ins> "electron": "25.8.2", </ins> "eslint": "8.36.0", "eslint-plugin-header": "3.1.1", "eslint-plugin-jsdoc": "^46.5.0",


{ "name": "code-oss-dev", "version": "1.80.0", <del> "distro": "cbc1aeab0c196a6c6314cf4df21228d9016c70d1", </del> <ins> "distro": "6ee5ac9f5980f3dd5aaf2948d43e6adced9c8b43", </ins> "author": { "name": "Microsoft Corporation" },


this.#historyService = historyService; codeEditorService.registerDecorationType('interactive-decoration', DECORATION_KEY, {}); <ins> this._register(this.#keybindingService.onDidUpdateKeybindings(this.#updateInputDecoration, this)); </ins> } protected createEditor(parent: HTMLElement): void {


} } <del> let excludePatternOrDisregardExcludes: string | false = false; </del> <ins> let excludePatternOrDisregardExcludes: string | false | undefined = undefined; </ins> if (exclude === null) { excludePatternOrDisregardExcludes = false; } else if (exclude) {


this.toDispose.push(this.debugService.getViewModel().onWillUpdateViews(() => this.updateInlineValuesScheduler.schedule())); this.toDispose.push(this.debugService.getViewModel().onDidEvaluateLazyExpression(() => this.updateInlineValuesScheduler.schedule())); this.toDispose.push(this.editor.onDidChangeModel(async () => { <del> const stackFrame = this.debugService.getViewModel().focusedStackFrame; const model = this.editor.getModel(); if (model) { this.applyHoverConfiguration(model, stackFrame); } </del> <ins> this.updateHoverConfiguration(); </ins> this.toggleExceptionWidget(); this.hideHoverWidget(); this._wordToLineNumbersMap = undefined; <ins> const stackFrame = this.debugService.getViewModel().focusedStackFrame; </ins> await this.updateInlineValueDecorations(stackFrame); })); this.toDispose.push(this.editor.onDidScrollChange(() => {


import { CancellationToken } from 'vs/base/common/cancellation'; import { KeyCode } from 'vs/base/common/keyCodes'; import { Disposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle'; <del> import { Constants } from 'vs/base/common/uint'; </del> import { ContentWidgetPositionPreference, IActiveCodeEditor, ICodeEditor, IContentWidget, IContentWidgetPosition, IEditorMouseEvent, MouseTargetType } from 'vs/editor/browser/editorBrowser'; import { ConfigurationChangedEvent, EditorOption } from 'vs/editor/common/config/editorOptions'; import { Position } from 'vs/editor/common/core/position';


} }); }, 0); <del> }); </del> <ins> }, () => listener.dispose()); </ins> return DiskSearch.collectResults(promise); }


error: message }); } <ins> private telemetryDebugAddBreakpoint(breakpoint: IBreakpoint, context: string): TPromise<any> { /* __GDPR__ "debugAddBreakpoint" : { "context": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }, "hasCondition": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }, "hasHitCondition": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }, "hasLogMessage": { "classification": "SystemMetaData", "purpose": "FeatureInsight" } } */ return this.telemetryService.publicLog('debugAddBreakpoint', { context: context, hasCondition: !!breakpoint.condition, hasHitCondition: !!breakpoint.hitCondition, hasLogMessage: !!breakpoint.logMessage }); } </ins> }


processCallbacks.push(child => { child.stdout.on('data', (data: Buffer) => console.log(data.toString('utf8').trim())); child.stderr.on('data', (data: Buffer) => console.log(data.toString('utf8').trim())); return new TPromise<void>(c => child.once('exit', () => c(null))); }); } <ins> // If we are running with input from stdin, pipe that into a file and // open this file via arguments. let isReadingFromStdin: boolean; try { isReadingFromStdin = !process.stdin.isTTY; // Via https://twitter.com/MylesBorins/status/782009479382626304 } catch (error) { // Windows workaround for https://github.com/nodejs/node/issues/11656 } let stdinFilePath: string; if (isReadingFromStdin) { let stdinFileError: Error; stdinFilePath = paths.join(os.tmpdir(), `stdin-${Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 6)}.txt`); try { // Pipe into tmp file process.stdin.setEncoding('utf8'); process.stdin.pipe(fs.createWriteStream(stdinFilePath)); // Make sure to open tmp file argv.push(stdinFilePath); // Enable --wait to get all data argv.push('--wait'); args.wait = true; } catch (error) { stdinFileError = error; } if (args.verbose) { if (stdinFileError) { console.error(`Failed to create file to read via stdin: ${stdinFileError.toString()}`); } else { console.log(`Reading from stdin via: ${stdinFilePath}`); } } } </ins> // If we are started with --wait create a random temporary file // and pass it over to the starting instance. We can use this file // to wait for it to be deleted to monitor that the edited file


if (userDataProfileImportState.isEmpty()) { await importAction.run(); } else { <del> await this.showProfilePreviewView(IMPORT_PROFILE_PREVIEW_VIEW, profileTemplate.name, importAction, new BarrierAction(barrier, new Action('cancel', localize('cancel', "Cancel"))), false, userDataProfileImportState); </del> <ins> await this.showProfilePreviewView(IMPORT_PROFILE_PREVIEW_VIEW, profileTemplate.name, importAction, new BarrierAction(barrier, new Action('cancel', localize('cancel', "Cancel")), this.notificationService), false, userDataProfileImportState); </ins> } await barrier.wait(); await this.hideProfilePreviewView(IMPORT_PROFILE_PREVIEW_VIEW);


} })); <del> const progressBar = new ProgressBar(container, this.styles.progressBar); progressBar.getContainer().classList.add('quick-input-progress'); </del> const focusTracker = dom.trackFocus(container); this._register(focusTracker); this._register(dom.addDisposableListener(container, dom.EventType.FOCUS, e => {


"dependencies": { "applicationinsights": "1.0.8", "chokidar": "3.5.1", <ins> "eslint-plugin-header": "3.1.1", </ins> "graceful-fs": "4.2.6", "http-proxy-agent": "^2.1.0", "https-proxy-agent": "^2.2.3",


id: SelectionToWatchExpressionsAction.ID, label: SelectionToWatchExpressionsAction.LABEL, alias: 'Debug: Add to Watch', <del> precondition: ContextKeyExpr.and(EditorContextKeys.editorTextFocus), </del> <ins> precondition: ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, EditorContextKeys.editorTextFocus), </ins> contextMenuOpts: { group: 'debug', order: 1


rows: 30 }); instantiationService.stub(IStorageService, new TestStorageService()); <del> instantiationService.stub(ITerminalContributionService, { quickFixes: [] } as Partial<ITerminalContributionService>); </del> <ins> instantiationService.stub(ITerminalContributionService, { quickFixes: new Promise((r) => { r([]); }) } as Partial<ITerminalContributionService>); </ins> instantiationService.stub(ITerminalQuickFixService, { onDidRegisterProvider: new Emitter().event, onDidUnregisterProvider: new Emitter().event, onDidRegisterCommandSelector: new Emitter().event } as Partial<ITerminalQuickFixService>); instantiationService.stub(IConfigurationService, new TestConfigurationService()); instantiationService.stub(ILabelService, {} as Partial<ILabelService>);


* with the next editor or if it will be kept. */ preview?: boolean; <ins> /** * An optional selection to apply for the document in the [editor](#TextEditor). */ selection?: Range; </ins> } /**


}); const searchOperation = await startInput.ongoingSearchOperation; <del> this.onSearchComplete(searchOperation, config, startInput); </del> <ins> await this.onSearchComplete(searchOperation, config, startInput); </ins> } private async onSearchComplete(searchOperation: ISearchComplete, startConfig: SearchConfiguration, startInput: SearchEditorInput) {


model.dispose(); mode.dispose(); }); <ins> test('issue #111128: Multicursor `Enter` issue with indentation', () => { const model = createTextModel('    let a, b, c;', { detectIndentation: false, insertSpaces: false, tabSize: 4 }, mode.getLanguageIdentifier()); withTestCodeEditor(null, { model: model }, (editor, viewModel) => { editor.setSelections([ new Selection(1, 11, 1, 11), new Selection(1, 14, 1, 14), ]); viewModel.type('n', 'keyboard'); assert.equal(model.getValue(), '    let a,nt b,nt c;'); }); }); </ins> }); interface ICursorOpts {


builtin return fi <ins> __vsc_initialized="0" </ins> __vsc_in_command_execution="1" __vsc_last_history_id=0


const element = this.options[index]; let optionDisabled: boolean; index === this.disabledOptionIndex ? optionDisabled = true : optionDisabled = false; <del> listEntries.push({ optionText: element, optionDisabled: optionDisabled }); </del> <ins> const optionDescription = this.detailsProvider ? this.detailsProvider(index) : { details: null, isMarkdown: false }; listEntries.push({ optionText: element, optionDisabled: optionDisabled, optionDescriptionText: optionDescription.details }); </ins> } this.selectList.splice(0, this.selectList.length, listEntries);


.monaco-workbench .terminal-action.new { background: url('new.svg') center center no-repeat; } /* Dark theme / HC theme */ .vs-dark .monaco-workbench .terminal-action.kill, .hc-black .monaco-workbench .terminal-action.kill { background: url('kill-inverse.svg') center center no-repeat; } <del> .vs-dark .monaco-workbench .terminal-action.new, .hc-black .monaco-workbench .terminal-action.new { background: url('new-inverse.svg') center center no-repeat; } </del>  No newline at end of file <ins> .vs-dark .monaco-workbench .terminal-action.new, .hc-black .monaco-workbench .terminal-action.new { background: url('new-inverse.svg') center center no-repeat; } .vs-dark .monaco-workbench.mac .panel.integrated-terminal .xterm-rows, .hc-black .monaco-workbench.mac .panel.integrated-terminal .xterm-rows { cursor: -webkit-image-set(url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAQAAAC1+jfqAAAAL0lEQVQoz2NgCD3x//9/BhBYBWdhgFVAiVW4JBFKGIa4AqD0//9D3pt4I4tAdAMAHTQ/j5Zom30AAAAASUVORK5CYII=') 1x, url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAQAAADZc7J/AAAAz0lEQVRIx2NgYGBY/R8I/vx5eelX3n82IJ9FxGf6tksvf/8FiTMQAcAGQMDvSwu09abffY8QYSAScNk45G198eX//yev73/4///701eh//kZSARckrNBRvz//+8+6ZohwCzjGNjdgQxkAg7B9WADeBjIBqtJCbhRA0YNoIkBSNmaPEMoNmA0FkYNoFKhapJ6FGyAH3nauaSmPfwI0v/3OukVi0CIZ+F25KrtYcx/CTIy0e+rC7R1Z4KMICVTQQ14feVXIbR695u14+Ir4gwAAD49E54wc1kWAAAAAElFTkSuQmCC') 2x) 5 8, text; } </ins>  No newline at end of file


this.show(); } })); <ins> this._register(this._configurationService.onDidChangeConfiguration(e => { if (e.affectsConfiguration(TerminalSettingId.AccessibleViewFocusOnCommandExecution)) { this._updateCommandExecutedListener(); } })); this._register(this._instance.capabilities.onDidAddCapability(e => { if (e.capability.type === TerminalCapability.CommandDetection) { this._updateCommandExecutedListener(); } })); </ins> } xtermReady(xterm: IXtermTerminal & { raw: Terminal }): void { const addon = this._instantiationService.createInstance(TextAreaSyncAddon, this._instance.capabilities); xterm.raw.loadAddon(addon);


const termBox = xterm.element.getBoundingClientRect(); const rowHeight = termBox.height / xterm.rows; const overlayHeight = stickyScrollLineCount * rowHeight; <del> this._element.style.bottom = `${termBox.height - overlayHeight + 1}px`; </del> <ins> // Adjust sticky scroll content if it would below the end of the command, obscuring the // following command. let endMarkerOffset = 0; if (!isPartialCommand && command.endMarker && command.endMarker.line !== -1) { if (buffer.viewportY + stickyScrollLineCount > command.endMarker.line) { const diff = buffer.viewportY + stickyScrollLineCount - command.endMarker.line; endMarkerOffset = diff * rowHeight; } } this._element.style.bottom = `${termBox.height - overlayHeight + 1 + endMarkerOffset}px`; </ins> } } else { this._setVisible(false);


} if (currentCount < desiredCount) { <del> const rulerWidth = dom.computeScreenAwareSize(1); </del> <ins> const rulerWidth = this._context.model.getTabSize(); </ins> let addCount = desiredCount - currentCount; while (addCount > 0) { let node = createFastDomNode(document.createElement('div'));


const runToolbar = this.setupRunToolbar(runButtonContainer, container, contextKeyService, disposables); const executionOrderLabel = DOM.append(cellContainer, $('div.execution-count-label')); <ins> executionOrderLabel.setAttribute('title', 'Execution Order'); </ins> const editorPart = DOM.append(cellContainer, $('.cell-editor-part')); const editorContainer = DOM.append(editorPart, $('.cell-editor-container'));


} private _showToggleVisibilityQuickPick() { <del> const quickPick = this._quickInputService.createQuickPick(); </del> <ins> const quickPick = this._register(this._quickInputService.createQuickPick()); </ins> quickPick.hideInput = true; quickPick.hideCheckAll = true; quickPick.canSelectMany = true;


jquery_d_ts = join(__dirname, '../../lib/jquery.d.ts'); // from source } <del> export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocumentRegions>, languageId: 'javascript' | 'typescript'): LanguageMode { </del> <ins> export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocumentRegions>, languageId: 'javascript' | 'typescript', workspace: Workspace): LanguageMode { </ins> let jsDocuments = getLanguageModelCache<TextDocument>(10, 60, document => documentRegions.get(document).getEmbeddedDocument(languageId)); const workingFile = languageId === 'javascript' ? 'vscode://javascript/1.js' : 'vscode://javascript/2.ts'; // the same 'file' is used for all contents <del> let compilerOptions: ts.CompilerOptions = { allowNonTsExtensions: true, allowJs: true, lib: ['lib.es6.d.ts'], target: ts.ScriptTarget.Latest, moduleResolution: ts.ModuleResolutionKind.Classic }; </del> <ins> let compilerOptions: ts.CompilerOptions = { allowNonTsExtensions: true, allowJs: true, lib: ['lib.es6.d.ts'], target: ts.ScriptTarget.Latest, moduleResolution: ts.ModuleResolutionKind.Classic, experimentalDecorators: false }; </ins> let currentTextDocument: TextDocument; let scriptFileVersion: number = 0; function updateCurrentTextDocument(doc: TextDocument) {


export const textSeparatorForeground = registerColor('textSeparator.foreground', { light: '#0000002e', dark: '#ffffff2e', hcDark: Color.black, hcLight: '#292929' }, nls.localize('textSeparatorForeground', "Color for text separators.")); export const textLinkForeground = registerColor('textLink.foreground', { light: '#006AB1', dark: '#3794FF', hcDark: '#3794FF', hcLight: '#0F4A85' }, nls.localize('textLinkForeground', "Foreground color for links in text.")); export const textLinkActiveForeground = registerColor('textLink.activeForeground', { light: '#006AB1', dark: '#3794FF', hcDark: '#3794FF', hcLight: '#0F4A85' }, nls.localize('textLinkActiveForeground', "Foreground color for links in text when clicked on and on mouse hover.")); <del> export const textPreformatForeground = registerColor('textPreformat.foreground', { light: '#A31515', dark: '#D7BA7D', hcDark: '#000000', hcLight: '#FFFFFF' }, nls.localize('textPreformatForeground', "Foreground color for preformatted text segments.")); </del> <ins> export const textPreformatForeground = registerColor('textPreformat.foreground', { light: '#A31515', dark: '#D7BA7D', hcDark: '#D7BA7D', hcLight: '#292929' }, nls.localize('textPreformatForeground', "Foreground color for preformatted text segments.")); </ins> export const textPreformatBackground = registerColor('textPreformat.background', { light: '#0000001A', dark: '#FFFFFF1A', hcDark: '#FFFFFF', hcLight: '#09345f' }, nls.localize('textPreformatBackground', "Background color for preformatted text segments.")); export const textBlockQuoteBackground = registerColor('textBlockQuote.background', { light: '#f2f2f2', dark: '#222222', hcDark: null, hcLight: '#F2F2F2' }, nls.localize('textBlockQuoteBackground', "Background color for block quotes in text.")); export const textBlockQuoteBorder = registerColor('textBlockQuote.border', { light: '#007acc80', dark: '#007acc80', hcDark: Color.white, hcLight: '#292929' }, nls.localize('textBlockQuoteBorder', "Border color for block quotes in text."));


options = { position: TypeConverters.fromViewColumn(columnOrOptions.viewColumn), preserveFocus: columnOrOptions.preserveFocus, <ins> selection: typeof columnOrOptions.selection === 'object' ? TypeConverters.fromRange(columnOrOptions.selection) : undefined, </ins> pinned: typeof columnOrOptions.preview === 'boolean' ? !columnOrOptions.preview : undefined }; } else {


import { debugToolBarBackground, debugToolBarBorder } from 'vs/workbench/contrib/debug/browser/debugColors'; import { CONTINUE_ID, CONTINUE_LABEL, DISCONNECT_AND_SUSPEND_ID, DISCONNECT_AND_SUSPEND_LABEL, DISCONNECT_ID, DISCONNECT_LABEL, FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, PAUSE_ID, PAUSE_LABEL, RESTART_LABEL, RESTART_SESSION_ID, REVERSE_CONTINUE_ID, STEP_BACK_ID, STEP_INTO_ID, STEP_INTO_LABEL, STEP_OUT_ID, STEP_OUT_LABEL, STEP_OVER_ID, STEP_OVER_LABEL, STOP_ID, STOP_LABEL } from 'vs/workbench/contrib/debug/browser/debugCommands'; import * as icons from 'vs/workbench/contrib/debug/browser/debugIcons'; <del> import { CONTEXT_DEBUG_STATE, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, IDebugConfiguration, IDebugService, State, VIEWLET_ID } from 'vs/workbench/contrib/debug/common/debug'; </del> <ins> import { CONTEXT_DEBUG_STATE, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_IN_DEBUG_MODE, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, IDebugConfiguration, IDebugService, State, VIEWLET_ID } from 'vs/workbench/contrib/debug/common/debug'; </ins> import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService'; import { Codicon } from 'vs/base/common/codicons';


case TerminalCommandId.New: { if (action instanceof MenuItemAction) { const actions = getTerminalActionBarArgs(TerminalLocation.Panel, this._terminalProfileService.availableProfiles, this._getDefaultProfileName(), this._terminalProfileService.contributedProfiles, this._terminalService, this._dropdownMenu); <ins> this._registerDisposableActions(actions.dropdownAction, actions.dropdownMenuActions); </ins> this._newDropdown?.dispose(); this._newDropdown = new DropdownWithPrimaryActionViewItem(action, actions.dropdownAction, actions.dropdownMenuActions, actions.className, this._contextMenuService, { hoverDelegate: options.hoverDelegate }, this._keybindingService, this._notificationService, this._contextKeyService, this._themeService, this._accessibilityService); this._updateTabActionBar(this._terminalProfileService.availableProfiles);


touch-action: none; width: 100%; border-radius: 4px; <ins> text-transform: capitalize; </ins> } .action-widget .monaco-list .monaco-list-row.action.focused:not(.option-disabled) {


import env = require('vs/base/common/platform'); import {ITextFileService, asFileResource} from 'vs/workbench/parts/files/common/files'; import {IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions} from 'vs/workbench/common/contributions'; <del> import {GlobalNewFileAction, SaveFileAsAction} from 'vs/workbench/parts/files/browser/fileActions'; </del> <ins> import {GlobalNewUntitledFileAction, SaveFileAsAction} from 'vs/workbench/parts/files/browser/fileActions'; </ins> import {FileTracker} from 'vs/workbench/parts/files/electron-browser/electronFileTracker'; import {TextFileService} from 'vs/workbench/parts/files/electron-browser/textFileServices'; import {OpenFolderAction, OPEN_FOLDER_ID, OPEN_FOLDER_LABEL, OpenFileAction, OPEN_FILE_ID, OPEN_FILE_LABEL, OpenFileFolderAction, OPEN_FILE_FOLDER_ID, OPEN_FILE_FOLDER_LABEL, ShowOpenedFileInNewWindow, GlobalRevealInOSAction, GlobalCopyPathAction, CopyPathAction, RevealInOSAction} from 'vs/workbench/parts/files/electron-browser/electronFileActions';


desktop-file-install /usr/share/applications/@@NAME@@-url-handler.desktop fi <ins> # Update mimetype database to pickup workspace mimetype if hash update-mime-database 2>/dev/null; then update-mime-database /usr/share/mime fi </ins> if [ "@@NAME@@" != "code-oss" ]; then # Remove the legacy bin command if this is the stable build if [ "@@NAME@@" = "code" ]; then


resolved "https://registry.yarnpkg.com/vscode-textmate/-/vscode-textmate-7.0.1.tgz#8118a32b02735dccd14f893b495fa5389ad7de79" integrity sha512-zQ5U/nuXAAMsh691FtV0wPz89nSkHbs+IQV8FDk+wew9BlSDhf4UmWGlWJfTR2Ti6xZv87Tj5fENzKf6Qk7aLw== <del> xterm-addon-search@0.9.0-beta.21: version "0.9.0-beta.21" resolved "https://registry.yarnpkg.com/xterm-addon-search/-/xterm-addon-search-0.9.0-beta.21.tgz#5348fe25676cdd89ce3be52ae62a316b6f266176" integrity sha512-jh6kfRCpWRvZZkV9QghFYesSYHjybaLNEyYAD6uilZYfNHoGLa0zPgUkLOqoECL7K6rhBmSYOkKbc9MG4wNFMQ== </del> <ins> xterm-addon-search@0.9.0-beta.22: version "0.9.0-beta.22" resolved "https://registry.yarnpkg.com/xterm-addon-search/-/xterm-addon-search-0.9.0-beta.22.tgz#18f2eabda82709cdd64dee003879b586869e28a3" integrity sha512-1I8W0bwjg6bUoNaESKHSkS9BN3Z9Xe44/zbUb6Un+pbb5Nun4LQvFwSLkAIdRrslxcbcHYIU/2Q7F1wCOWLbaA== </ins> xterm-addon-unicode11@0.4.0-beta.3: version "0.4.0-beta.3" resolved "https://registry.yarnpkg.com/xterm-addon-unicode11/-/xterm-addon-unicode11-0.4.0-beta.3.tgz#f350184155fafd5ad0d6fbf31d13e6ca7dea1efa" integrity sha512-FryZAVwbUjKTmwXnm1trch/2XO60F5JsDvOkZhzobV1hm10sFLVuZpFyHXiUx7TFeeFsvNP+S77LAtWoeT5z+Q== <del> xterm-addon-webgl@0.12.0-beta.28: version "0.12.0-beta.28" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.12.0-beta.28.tgz#252f88fd15816c23789659a0e2545682cf1eec9c" integrity sha512-xpqZRYlyv+aNdDl46W2Hi2fxakNvdJDmWhOwGHPjOmex+kOYdBvVn4rRZmJ7xrKFuQVOfzb3SQCmpZ/njCpBJA== </del> <ins> xterm-addon-webgl@0.12.0-beta.29: version "0.12.0-beta.29" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.12.0-beta.29.tgz#7a508595c4521d14d7ed4315a121f9e3f230a0f0" integrity sha512-NcZBsD0ar3ZpQX070hDIsyEBl/StRMNu6U+9crNpiD2rQVfkM1vcWkOv31Zlj3eu6/f8z5aStyZLRMCGFwiRbA== </ins> <del> xterm@4.19.0-beta.24: version "4.19.0-beta.24" resolved "https://registry.yarnpkg.com/xterm/-/xterm-4.19.0-beta.24.tgz#12b62877d4cf133f4626db3a15f6ed267b3bbcb5" integrity sha512-GydvC2ExdsfjkiXhUVuZtDhc89IZfyMLFgw/nwWHrvkyq4iCVsHbMloEObV3lZmv+0oRpcGtTiorfzdWGiHG0A== </del> <ins> xterm@4.19.0-beta.25: version "4.19.0-beta.25" resolved "https://registry.yarnpkg.com/xterm/-/xterm-4.19.0-beta.25.tgz#38f92d0fef1cfdb290ef8994449a04fa1a8c90a7" integrity sha512-pDiMWKN1Cj4+X/K9Xegp0SA0ZDEGVqiq7RPSy8oZO2wo2rze1BF20PAZb3/RSp30eY5WyOKilKnck4yNOsPzHw== </ins>


Sleep(1000); end; <del> Exec(ExpandConstant('{app}inno_updater.exe'), ExpandConstant('"{app}{#ExeBasename}.exe" ' + BoolToStr(LockFileExists())), '', SW_SHOW, ewWaitUntilTerminated, UpdateResultCode); </del> <ins> Exec(ExpandConstant('{app}toolsinno_updater.exe'), ExpandConstant('"{app}{#ExeBasename}.exe" ' + BoolToStr(LockFileExists())), '', SW_SHOW, ewWaitUntilTerminated, UpdateResultCode); </ins> end; end;


const shell = this._configurationService.getValue(TerminalSettingPrefix.Shell + platform); const shellArgs = this._configurationService.getValue(TerminalSettingPrefix.ShellArgs + platform); const profile = await this._terminalProfileResolverService.createProfileFromShellAndShellArgs(shell, shellArgs); <del> if (profile) { this._configurationService.updateValue(TerminalSettingPrefix.DefaultProfile + platform, profile.profileName); this._configurationService.updateValue(TerminalSettingPrefix.Shell + platform, undefined); this._configurationService.updateValue(TerminalSettingPrefix.ShellArgs + platform, undefined); this._logService.trace(`migrated from shell/shellArgs, ${shell} ${shellArgs} to profile ${JSON.stringify(profile)}`); </del> <ins> if (typeof profile === 'string') { await this._configurationService.updateValue(TerminalSettingPrefix.DefaultProfile + platform, profile); this._logService.trace(`migrated from shell/shellArgs, using existing profile ${profile}`); </ins> } else { <del> this._logService.trace('migration from shell/shellArgs to profile did not occur bc created profile was an exact match for existing one', shell, shellArgs); </del> <ins> const profiles = this._configurationService.inspect<{ [key: string]: ITerminalProfileObject }>(TerminalSettingPrefix.Profiles + platform).userValue || {}; const profileConfig: ITerminalProfileObject = { path: profile.path }; if (profile.args) { profileConfig.args = profile.args; } profiles[profile.profileName] = profileConfig; await this._configurationService.updateValue(TerminalSettingPrefix.Profiles + platform, profiles); await this._configurationService.updateValue(TerminalSettingPrefix.DefaultProfile + platform, profile.profileName); this._logService.trace(`migrated from shell/shellArgs, ${shell} ${shellArgs} to profile ${JSON.stringify(profile)}`); </ins> } <ins> await this._configurationService.updateValue(TerminalSettingPrefix.Shell + platform, undefined); await this._configurationService.updateValue(TerminalSettingPrefix.ShellArgs + platform, undefined); </ins> } } as IPromptChoice, ],


} .monaco-shell .monaco-menu .monaco-action-bar.vertical .submenu-indicator { <del> font-size: inherit; padding: 0 1em; </del> <ins> font-size: 60%; padding: 0 1.8em; </ins> } .monaco-shell .monaco-menu .action-item {


.monaco-workbench .part.basepanel > .content .scm-view .scm-editor-container .monaco-editor .margin, .monaco-workbench .part.basepanel > .content .scm-view .scm-editor-container .monaco-editor .monaco-editor-background { color: inherit; <del> background-color: unset </del> <ins> background-color: var(--vscode-input-background); </ins> } .scm-view .scm-editor-container .mtk1 {


return { position: this._showAtPosition, range: this._showAtRange, <del> preference: [ </del> <ins> preference: this._preferBelow ? [ ContentWidgetPositionPreference.BELOW, </ins> ContentWidgetPositionPreference.ABOVE, <del> ContentWidgetPositionPreference.BELOW ] </del> <ins> ] : [ ContentWidgetPositionPreference.ABOVE, ContentWidgetPositionPreference.BELOW, ], </ins> }; } return null;


} const actions = this.getFixAllActions(context.only); <del> if (this.client.bufferSyncSupport.hasPendingDiagnostics(document.uri)) { return actions; } </del> const diagnostics = this.diagnosticsManager.getDiagnostics(document.uri); if (!diagnostics.length) { // Actions are a no-op in this case but we still want to return them


import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey'; import { IExtensionTerminalProfile, ITerminalProfile, TerminalLocation, TerminalSettingId } from 'vs/platform/terminal/common/terminal'; import { ResourceContextKey } from 'vs/workbench/common/contextkeys'; <ins> import { TaskExecutionSupportedContext } from 'vs/workbench/contrib/tasks/common/taskService'; </ins> import { ICreateTerminalOptions, ITerminalLocationOptions, ITerminalService } from 'vs/workbench/contrib/terminal/browser/terminal'; import { TerminalCommandId, TERMINAL_VIEW_ID } from 'vs/workbench/contrib/terminal/common/terminal'; import { TerminalContextKeys, TerminalContextKeyStrings } from 'vs/workbench/contrib/terminal/common/terminalContextKey';


provideContent(): string { this._element = document.activeElement as HTMLElement; const content: string[] = []; <ins> content.push(CommentAccessibilityHelpNLS.introWidget); </ins> content.push(CommentAccessibilityHelpNLS.escape); content.push(this._descriptionForCommand(CommentCommandId.Add, CommentAccessibilityHelpNLS.addComment, CommentAccessibilityHelpNLS.addCommentNoKb)); <ins> content.push(this._descriptionForCommand(CommentCommandId.Submit, CommentAccessibilityHelpNLS.submitComment, CommentAccessibilityHelpNLS.submitCommentNoKb)); </ins> content.push(this._descriptionForCommand(CommentCommandId.NextRange, CommentAccessibilityHelpNLS.nextRange, CommentAccessibilityHelpNLS.nextRangeNoKb)); content.push(this._descriptionForCommand(CommentCommandId.PreviousRange, CommentAccessibilityHelpNLS.previousRange, CommentAccessibilityHelpNLS.previousRangeNoKb)); <del> content.push(this._descriptionForCommand(CommentCommandId.Submit, CommentAccessibilityHelpNLS.submitComment, CommentAccessibilityHelpNLS.submitCommentNoKb)); return content.join('nn'); </del> <ins> return content.join('n'); </ins> } onClose(): void { this._element?.focus();


}, }, { <ins> id: 'installGit', title: localize('gettingStarted.installGit.title', "Install Git"), description: localize('gettingStarted.installGit.description.interpolated', "Install Git to track changes in your projects.n{0}", Button(localize('installGit', "Install Git"), 'https://aka.ms/vscode-install-git')), when: 'git.missing', media: { type: 'svg', altText: 'Install Git.', path: 'git.svg', }, }, { </ins> id: 'tasks', title: localize('gettingStarted.tasks.title', "Automate your project tasks"), when: 'workspaceFolderCount != 0 && workspacePlatform != 'webworker'',


import { Emitter, Event } from 'vs/base/common/event'; import { KeyCode } from 'vs/base/common/keyCodes'; import { Disposable, DisposableStore, dispose, isDisposable, toDisposable } from 'vs/base/common/lifecycle'; <del> import { isIOS, language } from 'vs/base/common/platform'; </del> <ins> import { isIOS } from 'vs/base/common/platform'; </ins> import { escapeRegExpCharacters } from 'vs/base/common/strings'; import { isDefined, isUndefinedOrNull } from 'vs/base/common/types'; import { localize } from 'vs/nls';


import { IPartService, Position } from 'vs/workbench/services/part/common/partService'; const SPLIT_PANE_MIN_SIZE = 120; <ins> const TERMINAL_MIN_USEFUL_SIZE = 250; </ins> class SplitPaneContainer { private _height: number;


folder?: boolean; skipTrashBin?: boolean; maxSize?: number; <ins> contentsBase64?: string; </ins> } export interface IWorkspaceFileEdit {


"type": "object", "order": 20, "properties": { <ins> "php.builtInCompletions.enable": { "type": "boolean", "default": true, "description": "%configuration.builtInCompletions.enable%" }, </ins> "php.validate.enable": { "type": "boolean", "default": true,


constructor( private id: string, @IMenuService private readonly menuService: IMenuService <del> ) { super(); } </del> <ins> ) { } </ins> <del> /** * Caller is now responsible for disposing of the menu! */ getResourceActions(element: ITreeItem): { menu?: IMenu; actions: IAction[] } { const actions = this.getActions(MenuId.ViewItemContext, element, true); </del> <ins> getResourceActions(element: ITreeItem, disposableStore: DisposableStore): { menu?: IMenu; actions: IAction[] } { const actions = this.getActions(MenuId.ViewItemContext, element, disposableStore); </ins> return { menu: actions.menu, actions: actions.primary }; }


match acquire_singleton(&paths.tunnel_lockfile()).await { Ok(SingletonConnection::Client(stream)) => { debug!(log, "starting as client to singleton"); <ins> if gateway_args.name.is_none() || !gateway_args.install_extension.is_empty() || gateway_args.tunnel.tunnel_id.is_some() { warning!( log, "Command-line options will not be applied until the existing tunnel exits." ); } </ins> let should_exit = start_singleton_client(SingletonClientArgs { log: log.clone(), shutdown: shutdown.clone(),


font-family: var(--monaco-monospace-font); font-size: 12px; color: var(--vscode-textPreformat-foreground); <del> background-color: var(--vscode-textPreformat-background); </del> padding: 2px 5px; border-radius: 4px; }


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ import * as assert from 'assert'; import { CellKind } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { withTestNotebook } from 'vs/workbench/contrib/notebook/test/browser/testNotebookEditor'; import { ensureNoDisposablesAreLeakedInTestSuite } from 'vs/base/test/common/utils'; import { Event } from 'vs/base/common/event'; suite('CellDecorations', () => { ensureNoDisposablesAreLeakedInTestSuite(); test('Add and remove a cell decoration', async function () { await withTestNotebook( [ ['# header a', 'markdown', CellKind.Markup, [], {}], ], async (editor, viewModel) => { const cell = viewModel.cellAt(0); assert.ok(cell); let added = false; Event.once(cell.onCellDecorationsChanged)(e => added = !!e.added.find(decoration => decoration.className === 'style1')); const decorationIds = cell.deltaCellDecorations([], [{ className: 'style1' }]); assert.ok(cell.getCellDecorations().find(dec => dec.className === 'style1')); let removed = false; Event.once(cell.onCellDecorationsChanged)(e => removed = !!e.removed.find(decoration => decoration.className === 'style1')); cell.deltaCellDecorations(decorationIds, []); assert.ok(!cell.getCellDecorations().find(dec => dec.className === 'style1')); assert.ok(added); assert.ok(removed); }); }); test('Removing one cell decoration should not remove all', async function () { await withTestNotebook( [ ['# header a', 'markdown', CellKind.Markup, [], {}], ], async (editor, viewModel) => { const cell = viewModel.cellAt(0); assert.ok(cell); const decorationIds = cell.deltaCellDecorations([], [{ className: 'style1', outputClassName: 'style1' }]); cell.deltaCellDecorations([], [{ className: 'style1' }]); let styleRemoved = false; let outputStyleRemoved = false; Event.once(cell.onCellDecorationsChanged)(e => { styleRemoved = !!e.removed.find(decoration => decoration.className === 'style1'); outputStyleRemoved = !!e.removed.find(decoration => decoration.outputClassName === 'style1'); }); // remove the first style added, which should only remove the output class cell.deltaCellDecorations(decorationIds, []); assert.ok(!cell.getCellDecorations().find(dec => dec.outputClassName === 'style1')); assert.ok(cell.getCellDecorations().find(dec => dec.className === 'style1')); assert.ok(!styleRemoved); assert.ok(outputStyleRemoved); }); }); }); </ins>


// The widget's position is undefined until the widget has been displayed, so rely on the glyph position instead const existingCommentsAtLine = this._commentWidgets.filter(widget => widget.getGlyphPosition() === commentRange.endLineNumber); if (existingCommentsAtLine.length) { <del> existingCommentsAtLine.forEach(widget => widget.toggleExpand()); </del> <ins> const allExpanded = existingCommentsAtLine.every(widget => widget.expanded); existingCommentsAtLine.forEach(allExpanded ? widget => widget.collapse() : widget => widget.expand()); </ins> this.processNextThreadToAdd(); return; } else {


this.renderTree(undefined, forceRefresh); } else { this.settingsTreeModel = this.instantiationService.createInstance(SettingsTreeModel, this.viewState, this.workspaceTrustManagementService.isWorkspaceTrusted()); <del> this.settingsTreeModel.update(resolvedSettingsRoot); this.tocTreeModel.settingsTreeRoot = this.settingsTreeModel.root as SettingsTreeGroupElement; </del> <ins> this.refreshModels(resolvedSettingsRoot); </ins> // Don't restore the cached state if we already have a query value from calling _setOptions(). const cachedState = !this.viewState.query ? this.restoreCachedState() : undefined;


private setSourceOptions(): void { const sourceSelect = this.getElementById('issue-source')! as HTMLSelectElement; <del> const { issueType, fileOnExtension } = this.issueReporterModel.getData(); </del> <ins> const { issueType, fileOnExtension, selectedExtension } = this.issueReporterModel.getData(); </ins> let selected = sourceSelect.selectedIndex; <del> if (selected === -1 && fileOnExtension !== undefined) { selected = fileOnExtension ? 2 : 1; </del> <ins> if (selected === -1) { if (fileOnExtension !== undefined) { selected = fileOnExtension ? 2 : 1; } else if (selectedExtension?.isBuiltin) { selected = 1; } </ins> } sourceSelect.innerHTML = '';


depsStr = line.substring(shlibsDependsPrefix.length); } } <del> const requires = new Set(depsStr.split(', ').sort()); </del> <ins> // Refs https://chromium-review.googlesource.com/c/chromium/src/+/3572926 // Chromium depends on libgcc_s, is from the package libgcc1.  However, in // Bullseye, the package was renamed to libgcc-s1.  To avoid adding a dep // on the newer package, this hack skips the dep.  This is safe because // libgcc-s1 is a dependency of libc6.  This hack can be removed once // support for Debian Buster and Ubuntu Bionic are dropped. const filteredDeps = depsStr.split(', ').filter(dependency => { return !dependency.startsWith('libgcc-s1'); }).sort(); const requires = new Set(filteredDeps); </ins> return requires; }


import { EditSessionsFileSystemProvider } from 'vs/workbench/contrib/editSessions/browser/editSessionsFileSystemProvider'; import { isNative } from 'vs/base/common/platform'; import { WorkspaceFolderCountContext } from 'vs/workbench/common/contextkeys'; <ins> import { ThemeIcon } from 'vs/platform/theme/common/themeService'; </ins> registerSingleton(IEditSessionsLogService, EditSessionsLogService); registerSingleton(IEditSessionsWorkbenchService, EditSessionsWorkbenchService);


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


StartupNotify=false StartupWMClass=@@NAME_SHORT@@ Categories=Utility;TextEditor;Development;IDE; <del> MimeType=text/plain;inode/directory; </del> <ins> MimeType=text/plain;inode/directory;application/x-@@NAME@@-workspace; </ins> Actions=new-empty-window; Keywords=vscode;


import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; import { Emitter, Event } from 'vs/base/common/event'; import { DisposableStore } from 'vs/base/common/lifecycle'; <ins> import { EditorContextKeys } from 'vs/editor/common/editorContextKeys'; </ins> const CTX_QUICK_CHAT_IN_PROGRESS = new RawContextKey<boolean>('inlineChat.quickChatInProgress', false);


quickSuggestions: false, renderWhitespace: 'none', dropIntoEditor: { enabled: true }, <del> readOnly: true </del> <ins> readOnly: true, fontFamily: 'var(--monaco-monospace-font)' </ins> }; this._editorWidget = this._register(this._instantiationService.createInstance(CodeEditorWidget, this._editorContainer, editorOptions, codeEditorWidgetOptions)); } show(provider: IAccessibleContentProvider): void { const delegate: IContextViewDelegate = { <del> getAnchor: () => this._editorContainer, </del> <ins> getAnchor: () => { return { x: (window.innerWidth / 2) - (DIMENSION_DEFAULT.WIDTH / 2), y: (window.innerHeight / 2) - (this.editorWidget.getContentHeight() / 2) }; }, </ins> render: (container) => { return this._render(provider, container); },


.conflict-zone-root { background-color: var(--vscode-mergeEditor-change-background); <del> border: 1px dashed var(--vscode-mergeEditor-conflict-unhandledUnfocused-border); </del> <ins> border: 1px solid var(--vscode-mergeEditor-conflict-unhandledUnfocused-border); </ins> height: 90%; display: flex; align-items: center;


appendWholeWordsLabel: this._keybindingLabelFor(FIND_IDS.ToggleWholeWordCommand), appendRegexLabel: this._keybindingLabelFor(FIND_IDS.ToggleRegexCommand), validation: (value: string): InputBoxMessage | null => { <del> if (value.length === 0) { return null; } if (!this._findInput.getRegex()) { </del> <ins> if (value.length === 0 || !this._findInput.getRegex()) { </ins> return null; } try { <del> /* tslint:disable:no-unused-expression */ </del> <ins> /* tslint:disable-next-line:no-unused-expression */ </ins> new RegExp(value); <del> /* tslint:enable:no-unused-expression */ </del> return null; } catch (e) { return { content: e.message };


const isXHRResponse = (error: any): error is XHRResponse => typeof error?.status === 'number'; const request = async (uri: string, etag?: string): Promise<string> => { <del> const headers: Headers = { 'Accept-Encoding': 'gzip, deflate' }; </del> <ins> const headers: Headers = { 'Accept-Encoding': 'gzip, deflate', 'User-Agent': `${env.appName} (${env.appHost})` }; </ins> if (etag) { headers['If-None-Match'] = etag; }


/* padding must be on action-label because it has the bottom-border, because that's where the .checked class is */ } <ins> .settings-editor > .settings-header > .settings-header-controls .settings-tabs-widget > .monaco-action-bar .action-item.focused { outline-offset: -1.5px; } </ins> .settings-editor > .settings-header > .settings-header-controls .settings-tabs-widget > .monaco-action-bar .action-item .action-label { text-transform: none; font-size: 13px; <del> padding-bottom: 7px; </del> <ins> padding-bottom: 6.5px; </ins> padding-top: 7px; padding-left: 8px; padding-right: 8px; } <ins> .settings-editor > .settings-header > .settings-header-controls .settings-tabs-widget > .monaco-action-bar .action-item .action-label .dropdown-icon { padding-top: 2px; } </ins> .settings-editor > .settings-header > .settings-header-controls .settings-tabs-widget > .monaco-action-bar .action-item .action-label:not(.checked):not(:focus) { /* Add an extra pixel due to it not getting the outline */ padding-bottom: 8px;


linuxExecutableName: product.applicationName, winIcon: 'resources/win32/code.ico', token: process.env['GITHUB_TOKEN'], <del> repo: product.electronRepository || undefined </del> <ins> repo: product.electronRepository || undefined, validateChecksum: true, checksumFile: path.join(root, 'build', 'checksums', 'electron.txt'), </ins> }; function getElectron(arch) { return () => {


import { findExecutable, getShellIntegrationInjection, getWindowsBuildNumber, IShellIntegrationConfigInjection } from 'vs/platform/terminal/node/terminalEnvironment'; import { WindowsShellHelper } from 'vs/platform/terminal/node/windowsShellHelper'; import { IPty, IPtyForkOptions, IWindowsPtyForkOptions, spawn } from 'node-pty'; <ins> import { chunkInput } from 'vs/platform/terminal/common/terminalProcess'; </ins> const enum ShutdownConstants { /**


}); }); <ins> // --- document highlights test('"vscode.executeDocumentHighlights" API has stopped returning DocumentHighlight[]#200056', async function () { disposables.push(extHost.registerDocumentHighlightProvider(nullExtensionDescription, defaultSelector, <vscode.DocumentHighlightProvider>{ provideDocumentHighlights() { return [ new types.DocumentHighlight(new types.Range(0, 17, 0, 25), types.DocumentHighlightKind.Read) ]; } })); await rpcProtocol.sync(); return commands.executeCommand<vscode.DocumentHighlight[]>('vscode.executeDocumentHighlights', model.uri, new types.Position(0, 0)).then(values => { assert.ok(Array.isArray(values)); assert.strictEqual(values.length, 1); const [first] = values; assert.strictEqual(first.range.start.line, 0); assert.strictEqual(first.range.start.character, 17); assert.strictEqual(first.range.end.line, 0); assert.strictEqual(first.range.end.character, 25); }); }); </ins> // --- outline test('Outline, back and forth', function () {


inputBox.focus(); inputBox.select({ start: 0, end: lastDot > 0 && !stat.isDirectory ? lastDot : value.length }); <del> const done = once(async (success: boolean) => { </del> <ins> const done = once(async (success: boolean, finishEditing: boolean) => { </ins> label.element.style.display = 'none'; const value = inputBox.value; dispose(toDispose); container.removeChild(label.element); <del> // Timeout: once done rendering only then re-render #70902 setTimeout(() => editableData.onFinish(value, success), 0); </del> <ins> if (finishEditing) { // Timeout: once done rendering only then re-render #70902 setTimeout(() => editableData.onFinish(value, success), 0); } </ins> }); let ignoreDisposeAndBlur = true; setTimeout(() => ignoreDisposeAndBlur = false, 100); const blurDisposable = DOM.addDisposableListener(inputBox.inputElement, DOM.EventType.BLUR, () => { if (!ignoreDisposeAndBlur) { <del> done(inputBox.isInputValid()); </del> <ins> done(inputBox.isInputValid(), true); </ins> } });


if (this._currentCommand.commandStartMarker) { this._commandMarkers.push(this._currentCommand.commandStartMarker); } <ins> this._onCommandExecuted.fire(); </ins> } this._evaluateCommandMarkersWindows(); }


// or if no window is open (macOS only) shouldOpenInNewWindow ||= isMacintosh && windowsMainService.getWindowCount() === 0; <del> // Pass along edit session id if (params.get('editSessionId') !== null) { environmentService.editSessionId = params.get('editSessionId') ?? undefined; params.delete('editSessionId'); uri = uri.with({ query: params.toString() }); } </del> // Check for URIs to open in window const windowOpenableFromProtocolLink = app.getWindowOpenableFromProtocolLink(uri); logService.trace('app#handleURL: windowOpenableFromProtocolLink = ', windowOpenableFromProtocolLink);


import { IWorkspaceTrustRequestService } from 'vs/platform/workspace/common/workspaceTrust'; import { EditorInput } from 'vs/workbench/common/editor/editorInput'; import { EditorModel } from 'vs/workbench/common/editor/editorModel'; <del> import { CellFindMatchWithIndex, IActiveNotebookEditorDelegate, IBaseCellEditorOptions, ICellViewModel, INotebookEditorDelegate } from 'vs/workbench/contrib/notebook/browser/notebookBrowser'; </del> <ins> import { CellFindMatchWithIndex, CellFocusMode, IActiveNotebookEditorDelegate, IBaseCellEditorOptions, ICellViewModel, INotebookEditorDelegate } from 'vs/workbench/contrib/notebook/browser/notebookBrowser'; </ins> import { NotebookCellStateChangedEvent, NotebookLayoutInfo } from 'vs/workbench/contrib/notebook/browser/notebookViewEvents'; import { NotebookCellStatusBarService } from 'vs/workbench/contrib/notebook/browser/services/notebookCellStatusBarServiceImpl'; import { ListViewInfoAccessor, NotebookCellList } from 'vs/workbench/contrib/notebook/browser/view/notebookCellList';


import { IProductService } from 'vs/platform/product/common/productService'; import { registerNavigableContainer } from 'vs/workbench/browser/actions/widgetNavigationCommands'; import { IEditorProgressService } from 'vs/platform/progress/common/progress'; <ins> import { IExtensionManifest } from 'vs/platform/extensions/common/extensions'; </ins> export const enum SettingsFocusContext {


"tab.unfocusedHoverBackground": "#6e76811a", "terminal.foreground": "#ffffffc5", "terminal.inactiveSelectionBackground": "#E5EBF1", <del> "textBlockQuote.background": "#010409", </del> <ins> "textBlockQuote.background": "#f8f8f8", </ins> "textBlockQuote.border": "#0000001a", "textCodeBlock.background": "#6e768166", "textLink.activeForeground": "#005FB8",


this._register(addDisposableListener(window, EventType.RESIZE, e => this.onWindowResize(e, true))); // React to editor input changes <del> const appRootUri = URI.file(this.environmentService.appRoot); this._register(this.editorService.onDidActiveEditorChange(() => { // Touchbar this.updateTouchbarMenu(); // Potential data loss when editing files // from within the installation app root if (this.environmentService.isBuilt) { this.notifyOnAppRootEditors(appRootUri); } })); </del> <ins> this._register(this.editorService.onDidActiveEditorChange(() => this.updateTouchbarMenu())); </ins> // prevent opening a real URL inside the window for (const event of [EventType.DRAG_OVER, EventType.DROP]) {


} getCopyFromName(): string | undefined { <del> if (isUserDataProfile(this.copyFrom)) { if (this.copyFrom.isDefault) { return localize('copy from default', "{0} (Copy)", this.copyFrom.name); } return this.copyFrom.name; } if (this.template) { return this.template.name; } return undefined; </del> <ins> const name = isUserDataProfile(this.copyFrom) ? this.copyFrom.name : this.template ? this.template.name : undefined; return name === this.userDataProfilesService.defaultProfile.name ? localize('copy from default', "{0} (Copy)", name) : name; </ins> } protected override async getChildrenForResourceType(resourceType: ProfileResourceType): Promise<IProfileChildElement[]> {


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


import { Disposable } from 'vs/base/common/lifecycle'; import { IContextKeyService, IContextKey, setConstant as setConstantContextKey } from 'vs/platform/contextkey/common/contextkey'; import { InputFocusedContext, IsMacContext, IsLinuxContext, IsWindowsContext, IsWebContext, IsMacNativeContext, IsDevelopmentContext, IsIOSContext, ProductQualityContext, IsMobileContext } from 'vs/platform/contextkey/common/contextkeys'; <del> import { SplitEditorsVertically, InEditorZenModeContext, AuxiliaryBarVisibleContext, SideBarVisibleContext, PanelAlignmentContext, PanelMaximizedContext, PanelVisibleContext, EmbedderIdentifierContext, EditorTabsVisibleContext, IsMainEditorCenteredLayoutContext, MainEditorAreaVisibleContext, DirtyWorkingCopiesContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, HasWebFileSystemAccess, IsMainWindowFullscreenContext, OpenFolderWorkspaceSupportContext, RemoteNameContext, VirtualWorkspaceContext, WorkbenchStateContext, WorkspaceFolderCountContext, PanelPositionContext, TemporaryWorkspaceContext, TitleBarVisibleContext, TitleBarStyleContext, IsAuxiliaryWindowFocusedContext } from 'vs/workbench/common/contextkeys'; </del> <ins> import { SplitEditorsVertically, InEditorZenModeContext, AuxiliaryBarVisibleContext, SideBarVisibleContext, PanelAlignmentContext, PanelMaximizedContext, PanelVisibleContext, EmbedderIdentifierContext, EditorTabsVisibleContext, IsMainEditorCenteredLayoutContext, MainEditorAreaVisibleContext, DirtyWorkingCopiesContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, HasWebFileSystemAccess, IsMainWindowFullscreenContext, OpenFolderWorkspaceSupportContext, RemoteNameContext, VirtualWorkspaceContext, WorkbenchStateContext, WorkspaceFolderCountContext, PanelPositionContext, TemporaryWorkspaceContext, TitleBarVisibleContext, TitleBarStyleContext, IsAuxiliaryWindowFocusedContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, MultipleEditorGroupsContext, EditorsVisibleContext } from 'vs/workbench/common/contextkeys'; </ins> import { trackFocus, addDisposableListener, EventType, onDidRegisterWindow, getActiveWindow } from 'vs/base/browser/dom'; import { preferredSideBySideGroupDirection, GroupDirection, IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration';