'...' ]); }); <ins> test('Should match non-greedily', () => { assert.deepStrictEqual(parseLinkedText('a [link text 1](http://link.href "title1") b [link text 2](http://link.href "title2") c').nodes, [ 'a ', { label: 'link text 1', href: 'http://link.href', title: 'title1' }, ' b ', { label: 'link text 2', href: 'http://link.href', title: 'title2' }, ' c', ]); }); </ins> });


private _terminalProfiles: ReadonlyArray<IExtensionTerminalProfile> = []; get terminalProfiles() { return this._terminalProfiles; } <del> private _quickFixes: Array<ITerminalCommandSelector> = []; get quickFixes() { return this._quickFixes; } </del> <ins> quickFixes: Promise<Array<ITerminalCommandSelector>>; </ins> constructor() { <del> terminalsExtPoint.setHandler(contributions => { </del> <ins> this.quickFixes = new Promise((r) => terminalsExtPoint.setHandler(contributions => { </ins> this._terminalProfiles = contributions.map(c => { return c.value?.profiles?.filter(p => hasValidTerminalIcon(p)).map(e => { return { ...e, extensionIdentifier: c.description.identifier.value }; }) || []; }).flat(); <del> this._quickFixes = (contributions.filter(c => isProposedApiEnabled(c.description, 'terminalQuickFixProvider')).map(c => c.value.quickFixes ? c.value.quickFixes.map(fix => { return { ...fix, extensionIdentifier: c.description.identifier.value }; }) : [])).flat(); }); </del> <ins> const quickFixes = (contributions.filter(c => isProposedApiEnabled(c.description, 'terminalQuickFixProvider')).map(c => c.value.quickFixes ? c.value.quickFixes.map(fix => { return { ...fix, extensionIdentifier: c.description.identifier.value }; }) : [])).flat(); r(quickFixes); })); </ins> } }


new Promise<string | undefined>(resolve => setTimeout(() => resolve(''), 2000)) ]); <del> this.treatment = extensions ? JSON.parse(extensions) : { extensions: [] }; </del> <ins> try { this.treatment = extensions ? JSON.parse(extensions) : { extensions: [] }; } catch { } </ins> this.title = extensionListTitle ?? localize('gettingStarted.featuredTitle', 'Featured'); <del> if (this.treatment) { </del> <ins> if (this.treatment?.extensions && Array.isArray(this.treatment.extensions)) { </ins> const installed = await this.extensionManagementService.getInstalled(); <del> for (const extension of Object.values(this.treatment.extensions)) { </del> <ins> for (const extension of this.treatment.extensions) { </ins> if (installed.some(e => ExtensionIdentifier.equals(e.identifier.id, extension))) { this.ignoredExtensions.add(extension); }


assertSelections(editor, new Selection(1, 1, 1, 7), new Selection(2, 5, 2, 11)); editor.trigger('test', 'cut', {}); <del> assertContextKeys(contextKeys, false, false, false); </del> <ins> assertContextKeys(contextKeys, true, false, true); </ins> assertSelections(editor, new Selection(1, 1, 1, 1), new Selection(2, 5, 2, 5)); editor.trigger('test', 'type', { text: 'abc' }); <del> assertContextKeys(contextKeys, false, false, false); </del> <ins> assertContextKeys(contextKeys, true, false, true); </ins> ctrl.next(); assertContextKeys(contextKeys, false, false, false);


this._updateState(); <del> // we listen on model and selection changes. usually // both events come in together and this is to prevent // that we don't call _updateState twice. let state: EditorState; let dedupedUpdateState = () => { if (!state || !state.validate(this._editor)) { this._updateState(); state = new EditorState(this._editor, CodeEditorStateFlag.Selection | CodeEditorStateFlag.Value); } }; </del> this._snippetListener = [ <del> this._editor.onDidChangeModelContent(e => { if (e.isFlush) { this.cancel(); } else { setTimeout(dedupedUpdateState, 0); } }), this._editor.onDidChangeCursorSelection(dedupedUpdateState), </del> <ins> this._editor.onDidChangeModelContent(e => e.isFlush && this.cancel()), </ins> this._editor.onDidChangeModel(() => this.cancel()), <ins> this._editor.onDidChangeCursorSelection(() => this._updateState()) </ins> ]; }


configuration.isInitialStartup = false; // since this is a reload configuration.policiesData = this.policyService.serialize(); // set policies data again <del> configuration.editSessionId = this.environmentMainService.editSessionId; // set latest edit session id </del> configuration.profiles = { all: this.userDataProfilesService.profiles, current: this.profile || this.userDataProfilesService.defaultProfile,


import {ActionItem, BaseActionItem, Separator} from 'vs/base/browser/ui/actionbar/actionbar'; import {Scope, IActionBarRegistry, Extensions as ActionBarExtensions, ActionBarContributor} from 'vs/workbench/browser/actionBarRegistry'; import {IEditorInputActionContext, IEditorInputAction, EditorInputActionContributor} from 'vs/workbench/browser/parts/editor/baseEditor'; <del> import {AddToWorkingFiles, FocusWorkingFiles, FocusFilesExplorer, OpenPreviousWorkingFile, OpenNextWorkingFile, CloseAllFilesAction, CloseFileAction, CloseOtherFilesAction, GlobalCompareResourcesAction, GlobalNewFolderAction, RevertFileAction, SaveFilesAction, SaveAllAction, SaveFileAction, keybindingForAction, MoveFileToTrashAction, TriggerRenameFileAction, PasteFileAction, CopyFileAction, SelectResourceForCompareAction, CompareResourcesAction, NewFolderAction, NewFileAction, OpenToSideAction, ShowActiveFileInExplorer} from 'vs/workbench/parts/files/browser/fileActions'; </del> <ins> import {AddToWorkingFiles, FocusWorkingFiles, FocusFilesExplorer, OpenPreviousWorkingFile, OpenNextWorkingFile, CloseAllFilesAction, CloseFileAction, CloseOtherFilesAction, GlobalCompareResourcesAction, GlobalNewFileAction, GlobalNewFolderAction, RevertFileAction, SaveFilesAction, SaveAllAction, SaveFileAction, keybindingForAction, MoveFileToTrashAction, TriggerRenameFileAction, PasteFileAction, CopyFileAction, SelectResourceForCompareAction, CompareResourcesAction, NewFolderAction, NewFileAction, OpenToSideAction, ShowActiveFileInExplorer} from 'vs/workbench/parts/files/browser/fileActions'; </ins> import {RevertLocalChangesAction, AcceptLocalChangesAction, ConflictResolutionDiffEditorInput} from 'vs/workbench/parts/files/browser/saveErrorHandler'; import {SyncActionDescriptor} from 'vs/platform/actions/common/actions'; import {IWorkbenchActionRegistry, Extensions as ActionExtensions} from 'vs/workbench/common/actionRegistry';


import { ICommandHandlerDescription } from 'vs/platform/commands/common/commands'; import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands'; import { IWorkspaceSymbolProvider } from 'vs/workbench/parts/search/common/search'; <del> import { IEditorOptions } from 'vs/platform/editor/common/editor'; </del> <ins> import { ITextEditorOptions } from 'vs/platform/editor/common/editor'; </ins> export class ExtHostApiCommands {


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


export class UpdateManager extends events.EventEmitter { <del> private static DEFAULT_UPDATE_CHANNEL = 'stable'; </del> private _state: State; private explicitState: ExplicitState; private _availableUpdate: IUpdate;


`${process.env['ProgramW6432']}Gitusrbinbash.exe`, `${process.env['ProgramFiles']}Gitbinbash.exe`, `${process.env['ProgramFiles']}Gitusrbinbash.exe`, <ins> `${process.env['LocalAppData']}ProgramsGitbinbash.exe`, </ins> ] }; const promises: TPromise<[string, string]>[] = [];


import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; import { ILabelService } from 'vs/platform/label/common/label'; import { WorkbenchCompressibleObjectTree, getSelectionKeyboardEvent } from 'vs/platform/list/browser/listService'; <del> import { FastAndSlowPicks, IPickerQuickAccessItem, PickerQuickAccessProvider, Picks, TriggerAction } from 'vs/platform/quickinput/browser/pickerQuickAccess'; </del> <ins> import { FastAndSlowPicks, IPickerQuickAccessItem, IPickerQuickAccessSeparator, PickerQuickAccessProvider, Picks, TriggerAction } from 'vs/platform/quickinput/browser/pickerQuickAccess'; </ins> import { DefaultQuickAccessFilterValue, IQuickAccessProviderRunOptions } from 'vs/platform/quickinput/common/quickAccess'; <del> import { IKeyMods, IQuickPick, IQuickPickItem, IQuickPickSeparator, QuickInputHideReason } from 'vs/platform/quickinput/common/quickInput'; </del> <ins> import { IKeyMods, IQuickPick, IQuickPickItem, QuickInputHideReason } from 'vs/platform/quickinput/common/quickInput'; </ins> import { IWorkspaceContextService, IWorkspaceFolder } from 'vs/platform/workspace/common/workspace'; import { IWorkbenchEditorConfiguration } from 'vs/workbench/common/editor'; import { searchDetailsIcon, searchOpenInFileIcon, searchActivityBarIcon } from 'vs/workbench/contrib/search/browser/searchIcons';


.review-widget .body .review-comment .review-comment-contents .comment-reactions .action-item a.action-label.toolbar-toggle-pickReactions { display: none; background-size: 16px; <ins> font-size: 16px; </ins> width: 26px; height: 16px; background-repeat: no-repeat;


command: 'git.commit', title: l10n.t('{0} Continue', '$(check)'), tooltip: this.state.isCommitInProgress ? l10n.t('Continuing Rebase...') : l10n.t('Continue Rebase'), <del> arguments: [this.repository.sourceControl, ''] </del> <ins> arguments: [this.repository.sourceControl, null] </ins> }; }


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


<ins> [ { "c": "// from https://flutter.dev/", "t": "source.dart comment.line.double-slash.dart", "r": { "dark_plus": "comment: #6A9955", "light_plus": "comment: #008000", "dark_vs": "comment: #6A9955", "light_vs": "comment: #008000", "hc_black": "comment: #7CA668" } }, { "c": "import", "t": "source.dart meta.declaration.dart keyword.other.import.dart", "r": { "dark_plus": "keyword: #569CD6", "light_plus": "keyword: #0000FF", "dark_vs": "keyword: #569CD6", "light_vs": "keyword: #0000FF", "hc_black": "keyword: #569CD6" } }, { "c": " ", "t": "source.dart meta.declaration.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "'package:flutter/material.dart'", "t": "source.dart meta.declaration.dart string.interpolated.single.dart", "r": { "dark_plus": "string: #CE9178", "light_plus": "string: #A31515", "dark_vs": "string: #CE9178", "light_vs": "string: #A31515", "hc_black": "string: #CE9178" } }, { "c": ";", "t": "source.dart meta.declaration.dart punctuation.terminator.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "void", "t": "source.dart storage.type.primitive.dart", "r": { "dark_plus": "storage.type: #569CD6", "light_plus": "storage.type: #0000FF", "dark_vs": "storage.type: #569CD6", "light_vs": "storage.type: #0000FF", "hc_black": "storage.type: #569CD6" } }, { "c": " ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "main", "t": "source.dart entity.name.function.dart", "r": { "dark_plus": "entity.name.function: #DCDCAA", "light_plus": "entity.name.function: #795E26", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "entity.name.function: #DCDCAA" } }, { "c": "() ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "async", "t": "source.dart keyword.control.dart", "r": { "dark_plus": "keyword.control: #C586C0", "light_plus": "keyword.control: #AF00DB", "dark_vs": "keyword.control: #569CD6", "light_vs": "keyword.control: #0000FF", "hc_black": "keyword.control: #C586C0" } }, { "c": " {", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "  ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "runApp", "t": "source.dart entity.name.function.dart", "r": { "dark_plus": "entity.name.function: #DCDCAA", "light_plus": "entity.name.function: #795E26", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "entity.name.function: #DCDCAA" } }, { "c": "(", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "    ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "MaterialApp", "t": "source.dart support.class.dart", "r": { "dark_plus": "support.class: #4EC9B0", "light_plus": "support.class: #267F99", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "support.class: #4EC9B0" } }, { "c": "(", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "      debugShowCheckedModeBanner", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": ":", "t": "source.dart keyword.operator.ternary.dart", "r": { "dark_plus": "keyword.operator: #D4D4D4", "light_plus": "keyword.operator: #000000", "dark_vs": "keyword.operator: #D4D4D4", "light_vs": "keyword.operator: #000000", "hc_black": "keyword.operator: #D4D4D4" } }, { "c": " ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "false", "t": "source.dart constant.language.dart", "r": { "dark_plus": "constant.language: #569CD6", "light_plus": "constant.language: #0000FF", "dark_vs": "constant.language: #569CD6", "light_vs": "constant.language: #0000FF", "hc_black": "constant.language: #569CD6" } }, { "c": ",", "t": "source.dart punctuation.comma.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "      home", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": ":", "t": "source.dart keyword.operator.ternary.dart", "r": { "dark_plus": "keyword.operator: #D4D4D4", "light_plus": "keyword.operator: #000000", "dark_vs": "keyword.operator: #D4D4D4", "light_vs": "keyword.operator: #000000", "hc_black": "keyword.operator: #D4D4D4" } }, { "c": " ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "Scaffold", "t": "source.dart support.class.dart", "r": { "dark_plus": "support.class: #4EC9B0", "light_plus": "support.class: #267F99", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "support.class: #4EC9B0" } }, { "c": "(", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "        body", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": ":", "t": "source.dart keyword.operator.ternary.dart", "r": { "dark_plus": "keyword.operator: #D4D4D4", "light_plus": "keyword.operator: #000000", "dark_vs": "keyword.operator: #D4D4D4", "light_vs": "keyword.operator: #000000", "hc_black": "keyword.operator: #D4D4D4" } }, { "c": " ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "MyApp", "t": "source.dart support.class.dart", "r": { "dark_plus": "support.class: #4EC9B0", "light_plus": "support.class: #267F99", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "support.class: #4EC9B0" } }, { "c": "()", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": ",", "t": "source.dart punctuation.comma.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "      )", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": ",", "t": "source.dart punctuation.comma.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "    )", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": ",", "t": "source.dart punctuation.comma.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "  )", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": ";", "t": "source.dart punctuation.terminator.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "}", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "class", "t": "source.dart keyword.declaration.dart", "r": { "dark_plus": "keyword: #569CD6", "light_plus": "keyword: #0000FF", "dark_vs": "keyword: #569CD6", "light_vs": "keyword: #0000FF", "hc_black": "keyword: #569CD6" } }, { "c": " ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "MyApp", "t": "source.dart support.class.dart", "r": { "dark_plus": "support.class: #4EC9B0", "light_plus": "support.class: #267F99", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "support.class: #4EC9B0" } }, { "c": " ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "extends", "t": "source.dart keyword.declaration.dart", "r": { "dark_plus": "keyword: #569CD6", "light_plus": "keyword: #0000FF", "dark_vs": "keyword: #569CD6", "light_vs": "keyword: #0000FF", "hc_black": "keyword: #569CD6" } }, { "c": " ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "StatefulWidget", "t": "source.dart support.class.dart", "r": { "dark_plus": "support.class: #4EC9B0", "light_plus": "support.class: #267F99", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "support.class: #4EC9B0" } }, { "c": " {", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "  ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "@override", "t": "source.dart storage.type.annotation.dart", "r": { "dark_plus": "storage.type: #569CD6", "light_plus": "storage.type: #0000FF", "dark_vs": "storage.type: #569CD6", "light_vs": "storage.type: #0000FF", "hc_black": "storage.type: #569CD6" } }, { "c": "  ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "_MyAppState", "t": "source.dart support.class.dart", "r": { "dark_plus": "support.class: #4EC9B0", "light_plus": "support.class: #267F99", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "support.class: #4EC9B0" } }, { "c": " ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "createState", "t": "source.dart entity.name.function.dart", "r": { "dark_plus": "entity.name.function: #DCDCAA", "light_plus": "entity.name.function: #795E26", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "entity.name.function: #DCDCAA" } }, { "c": "() ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "=>", "t": "source.dart keyword.operator.closure.dart", "r": { "dark_plus": "keyword.operator: #D4D4D4", "light_plus": "keyword.operator: #000000", "dark_vs": "keyword.operator: #D4D4D4", "light_vs": "keyword.operator: #000000", "hc_black": "keyword.operator: #D4D4D4" } }, { "c": " ", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "_MyAppState", "t": "source.dart support.class.dart", "r": { "dark_plus": "support.class: #4EC9B0", "light_plus": "support.class: #267F99", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "support.class: #4EC9B0" } }, { "c": "()", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": ";", "t": "source.dart punctuation.terminator.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } }, { "c": "}", "t": "source.dart", "r": { "dark_plus": "default: #D4D4D4", "light_plus": "default: #000000", "dark_vs": "default: #D4D4D4", "light_vs": "default: #000000", "hc_black": "default: #FFFFFF" } } ] </ins>  No newline at end of file


} public get lineNumbers(): number[] { return this._lineNumbers; }


this.editor.updateOptions({ padding: { top: defaultCodeblockPadding, bottom: bottomPadding } }); } <ins> private _configureForScreenReader(): void { const toolbarElt = this.toolbar.getElement(); if (this._accessibilityService.isScreenReaderOptimized()) { toolbarElt.style.display = 'block'; toolbarElt.ariaLabel = this._configurationService.getValue(AccessibilityVerbositySettingId.Chat) ? localize('chat.codeBlock.toolbarVerbose', 'Toolbar for code block which can be reached via tab') : localize('chat.codeBlock.toolbar', 'Code block toolbar'); } else { toolbarElt.style.display = ''; } } </ins> private getEditorOptionsFromConfig(): IEditorOptions { return { wordWrap: this.options.configuration.resultEditor.wordWrap,


"less.lint.emptyRules.desc": "Do not use empty rulesets.", "less.lint.float.desc": "Avoid using `float`. Floats lead to fragile CSS that is easy to break if one aspect of the layout changes.", "less.lint.fontFaceProperties.desc": "`@font-face` rule must define `src` and `font-family` properties.", <del> "less.lint.hexColorLength.desc": "Hex colors must consist of three or six hex numbers.", </del> <ins> "less.lint.hexColorLength.desc": "Hex colors must consist of 3, 4, 6 or 8 hex numbers.", </ins> "less.lint.idSelector.desc": "Selectors should not contain IDs because these rules are too tightly coupled with the HTML.", "less.lint.ieHack.desc": "IE hacks are only necessary when supporting IE7 and older.", "less.lint.important.desc": "Avoid using `!important`. It is an indication that the specificity of the entire CSS has gotten out of control and needs to be refactored.",


disturl "https://electronjs.org/headers" <del> target "19.1.8" </del> <ins> target "19.1.9" </ins> runtime "electron" build_from_source "true"


} } <del> private async getWebiewContents(): Promise<string> { </del> <ins> private async getWebviewContents(): Promise<string> { </ins> const version = Date.now().toString(); const settings = { isMac: process.platform === 'darwin',


logMessage: l.logMessage } ); <del> this.debugService.addBreakpoints(uri.revive(dto.uri), rawbps); </del> <ins> this.debugService.addBreakpoints(uri.revive(dto.uri), rawbps, 'extension'); </ins> } else if (dto.type === 'function') { this.debugService.addFunctionBreakpoint(dto.functionName, dto.id); }


currentHistoryItemRemoteRef?: ISCMHistoryItemRef, currentHistoryItemBaseRef?: ISCMHistoryItemRef ): number { <del> const getHistoryItemRefPriority = (ref: ISCMHistoryItemRef) => { </del> <ins> const getHistoryItemRefOrder = (ref: ISCMHistoryItemRef) => { </ins> if (ref.id === currentHistoryItemRef?.id) { return 1; } else if (ref.id === currentHistoryItemRemoteRef?.id) {


} public unhide() { <del> this.element.style.visibility = 'visible'; </del> <ins> this.element.style.visibility = ''; </ins> this.updateMarkupDimensions(); }


import { ICommentThreadChangedEvent } from 'vs/workbench/contrib/comments/common/commentModel'; import { CommentMenus } from 'vs/workbench/contrib/comments/browser/commentMenus'; import { ICellRange } from 'vs/workbench/contrib/notebook/common/notebookRange'; <ins> import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService'; </ins> export const ICommentService = createDecorator<ICommentService>('commentService');


} } <del> private _getPicksFromMatches(matches: FileMatch[], limit: number): (IQuickPickSeparator | ITextSearchQuickAccessItem)[] { </del> <ins> private _getPicksFromMatches(matches: FileMatch[], limit: number): (IPickerQuickAccessSeparator | ITextSearchQuickAccessItem)[] { </ins> matches = matches.sort(searchComparer); const files = matches.length > limit ? matches.slice(0, limit) : matches; <del> const picks: Array<ITextSearchQuickAccessItem | IQuickPickSeparator> = []; </del> <ins> const picks: Array<ITextSearchQuickAccessItem | IPickerQuickAccessSeparator> = []; </ins> for (let fileIndex = 0; fileIndex < matches.length; fileIndex++) { if (fileIndex === limit) {


// --- from extension host process $tryShowTextDocument(resource: URI, options: ITextDocumentShowOptions): TPromise<string> { <del> const editorOptions: IEditorOptions = { </del> <ins> const editorOptions: ITextEditorOptions = { </ins> preserveFocus: options.preserveFocus, <del> pinned: options.pinned </del> <ins> pinned: options.pinned, selection: options.selection </ins> }; const input = {


this._labelElement = document.createElement('div'); this._labelElement.classList.add('monaco-button-label'); <del> this._labelElement.tabIndex = -1; </del> this._element.appendChild(this._labelElement); this._descriptionElement = document.createElement('div'); this._descriptionElement.classList.add('monaco-button-description'); <del> this._descriptionElement.tabIndex = -1; </del> this._element.appendChild(this._descriptionElement); }


<key>list_paragraph</key> <dict> <key>begin</key> <del> <string>(^|G)(?=S)(?![*+-]s|[0-9]+.s)</string> </del> <ins> <string>(^|G)(?=S)(?![*+->]s|[0-9]+.s)</string> </ins> <key>name</key> <string>meta.paragraph.markdown</string> <key>patterns</key>


resetStateMachine:boolean, hasOpenParens:boolean, hasOpenSquareBracket:boolean, <del> hasOpenCurlyBracket:boolean; </del> <ins> hasOpenCurlyBracket:boolean, characterClassifier:CharacterClassifier = new CharacterClassifier(); </ins> for (i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) { line = model.getLineContent(i);


const modelVersionNow = model.getAlternativeVersionId(); const { item } = event; <ins> // const tasks: Promise<any>[] = []; const cts = new CancellationTokenSource(); </ins> // pushing undo stops *before* additional text edits and // *after* the main edit if (!(flags & InsertFlags.NoBeforeUndoStop)) {


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


"git": { "name": "electron", "repositoryUrl": "https://github.com/electron/electron", <del> "commitHash": "a5cafd174d2027529d0b251e5b8e58da2b364e5b" </del> <ins> "commitHash": "b05ccd812e3bb3de5b1546a313e298961653e942" </ins> } }, "isOnlyProductionDependency": true, "license": "MIT", <del> "version": "19.0.11" </del> <ins> "version": "19.0.12" </ins> }, { "component": {


|| installedExtension.preRelease !== e.preRelease // Install if the extension pre-release preference has changed ) { if (await this.extensionManagementService.canInstall(extension)) { <del> this.logService.trace(`${syncResourceLogLabel}: Installing extension...`, e.identifier.id, extension.version); await this.extensionManagementService.installFromGallery(extension, { isMachineScoped: false, donotIncludePackAndDependencies: true, installPreReleaseVersion: e.preRelease, profileLocation: profile.extensionsResource } /* set isMachineScoped value to prevent install and sync dialog in web */); this.logService.info(`${syncResourceLogLabel}: Installed extension.`, e.identifier.id, extension.version); removeFromSkipped.push(extension.identifier); </del> <ins> extensionsToInstall.push([e, extension]); </ins> } else { this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension because it cannot be installed.`, extension.displayName || extension.identifier.id); addToSkipped.push(e);


} const cell = new MarkupCell(init.cellId, init.mime, init.content, top, init.metadata); <del> cell.element.style.visibility = visible ? 'visible' : 'hidden'; </del> <ins> cell.element.style.visibility = visible ? '' : 'hidden'; </ins> this._markupCells.set(init.cellId, cell); await cell.ready;


dispose: () => combinedDisposable(disposables).dispose() }; <del> const cacheKey = descriptor.resource.toString(); </del> <ins> const cacheKey = `${descriptor.resource.toString()}:${descriptor.etag}`; </ins> let ctrlPressed = false; let altPressed = false;


import { filter } from 'vs/base/common/objects'; import { assertType } from 'vs/base/common/types'; import { URI } from 'vs/base/common/uri'; <del> import { localize } from 'vs/nls'; </del> import { IRevertOptions, ISaveOptions, IUntypedEditorInput } from 'vs/workbench/common/editor'; import { EditorModel } from 'vs/workbench/common/editor/editorModel'; import { NotebookTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookTextModel'; import { ICellDto2, INotebookEditorModel, INotebookLoadOptions, IResolvedNotebookEditorModel, NotebookCellsChangeType, NotebookData } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { INotebookSerializer, INotebookService, SimpleNotebookProviderInfo } from 'vs/workbench/contrib/notebook/common/notebookService'; <del> import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions'; </del> import { IFilesConfigurationService } from 'vs/workbench/services/filesConfiguration/common/filesConfigurationService'; import { ILifecycleService } from 'vs/workbench/services/lifecycle/common/lifecycle'; import { IFileWorkingCopyManager } from 'vs/workbench/services/workingCopy/common/fileWorkingCopyManager';


} let index: number; <del> if (this.editor.hasModel() && (typeof lineNumber === 'number')) { </del> <ins> if (this.editor.hasModel() && (typeof lineNumber === 'number' || !this.widget.provider)) { </ins> index = this.model.findNextClosestChange(typeof lineNumber === 'number' ? lineNumber : this.editor.getPosition().lineNumber, true, this.widget.provider); } else { const providerChanges: number[] = this.model.mapChanges.get(this.widget.provider) ?? this.model.mapChanges.values().next().value;


**/extensions/markdown-language-features/notebook-out/** **/extensions/typescript-basics/test/colorize-fixtures/** **/extensions/**/dist/** <ins> **/extensions/typescript-language-features/test-workspace/** </ins>


updateOptions(newOptions: Partial<NotebookViewModelOptions>) { this._options = { ...this._options, ...newOptions }; <ins> this._viewCells.forEach(cell => cell.updateOptions({ readonly: this._options.isReadOnly })); </ins> this._onDidChangeOptions.fire(); }


dropdownActions.push(new SubmenuAction('split.profile', localize('splitTerminal', 'Split Terminal'), submenuActions)); dropdownActions.push(new Separator()); } <del> for (const [, configureActions] of dropdownMenu.getActions()) { for (const action of configureActions) { // make sure the action is a MenuItemAction if ('alt' in action) { dropdownActions.push(action); } } } </del> <ins> const actions = dropdownMenu.getActions(); dropdownActions.push(...Separator.join(...actions.map(a => a[1]))); </ins> const defaultSubmenuProfileAction = submenuActions.find(d => d.label.endsWith('(Default)')); if (defaultSubmenuProfileAction) {


"@vscode/vscode-languagedetection": "1.0.21", "@vscode/windows-process-tree": "^0.6.0", "@vscode/windows-registry": "^1.1.0", <del> "@xterm/addon-clipboard": "0.2.0-beta.39", "@xterm/addon-image": "0.9.0-beta.56", "@xterm/addon-search": "0.16.0-beta.56", "@xterm/addon-serialize": "0.14.0-beta.56", "@xterm/addon-unicode11": "0.9.0-beta.56", "@xterm/addon-webgl": "0.19.0-beta.56", "@xterm/headless": "5.6.0-beta.56", "@xterm/xterm": "5.6.0-beta.56", </del> <ins> "@xterm/addon-clipboard": "^0.2.0-beta.47", "@xterm/addon-image": "^0.9.0-beta.64", "@xterm/addon-search": "^0.16.0-beta.64", "@xterm/addon-serialize": "^0.14.0-beta.64", "@xterm/addon-unicode11": "^0.9.0-beta.64", "@xterm/addon-webgl": "^0.19.0-beta.64", "@xterm/headless": "^5.6.0-beta.64", "@xterm/xterm": "^5.6.0-beta.64", </ins> "cookie": "^0.4.0", "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.2",


readonly allowEditorOverflow = true; private readonly domNode = document.createElement('div'); <del> private readonly elements = h('.editor-dictation-widget@main', [h('span@mic')]); constructor(private readonly editor: ICodeEditor) { </del> <ins> constructor(private readonly editor: ICodeEditor, keybindingService: IKeybindingService) { </ins> super(); <del> this.domNode.appendChild(this.elements.root); this.domNode.style.zIndex = '1000'; reset(this.elements.mic, renderIcon(Codicon.micFilled)); </del> <ins> const actionBar = this._register(new ActionBar(this.domNode)); const stopActionKeybinding = keybindingService.lookupKeybinding(EditorDictationStopAction.ID)?.getLabel(); actionBar.push(toAction({ id: EditorDictationStopAction.ID, label: stopActionKeybinding ? localize('stopDictationShort1', "Stop Dictation ({0})", stopActionKeybinding) : localize('stopDictationShort2', "Stop Dictation"), class: ThemeIcon.asClassName(Codicon.micFilled), run: () => EditorDictation.get(editor)?.stop() }), { icon: true, label: false, keybinding: stopActionKeybinding }); this.domNode.classList.add('editor-dictation-widget'); this.domNode.appendChild(actionBar.domNode); </ins> } getId(): string {


setTimeout(() => { dom.addClass(this._innerDomNode, 'visible'); <ins> dom.addClass(this._innerDomNode, 'visible-transition'); </ins> this._innerDomNode.setAttribute('aria-hidden', 'false'); setTimeout(() => { this._findInput.select();


} rawUpdate(data: IRawModelUpdate): void { <ins> const threadIds: number[] = []; </ins> data.threads.forEach(thread => { <ins> threadIds.push(thread.id); </ins> if (!this.threads.has(thread.id)) { // A new thread came in, initialize it. this.threads.set(thread.id, new Thread(this, thread.name, thread.id));


} } <del> private notifyOnAppRootEditors(appRootUri: URI): void { const resourceUri = EditorResourceAccessor.getOriginalUri(this.editorService.activeEditor, { supportSideBySide: SideBySideEditor.BOTH }); const isResourceAppRootedFn = (uri: URI): boolean => this.uriIdentityService.extUri.isEqualOrParent(uri, appRootUri); let isResourceAppRooted = false; if (URI.isUri(resourceUri)) { if (isResourceAppRootedFn(resourceUri)) { isResourceAppRooted = true; } } else if (resourceUri) { if (resourceUri.primary && isResourceAppRootedFn(resourceUri.primary)) { isResourceAppRooted = true; } else if (resourceUri.secondary && isResourceAppRootedFn(resourceUri.secondary)) { isResourceAppRooted = true; } } // It is dangerous to edit files in the installation directory of Code because // an update will remove all files and replace them with the new version. // As such, we notify the user whenever an editor opens that is located somewhere // in the installation directory. // https://github.com/microsoft/vscode/issues/138815 if (isResourceAppRooted) { this.notificationService.prompt( Severity.Warning, localize('notifyOnAppRootEditors', "Files within the installation folder of '{0}' ({1}) will be OVERWRITTEN or DELETED IRREVERSIBLY without warning during a future update.", this.productService.nameShort, this.environmentService.appRoot), [{ label: localize('understood', 'Understood'), run: async () => { // Nothing to do } }], { neverShowAgain: { id: 'window.notifyOnAppRootEditors', isSecondary: true }, sticky: true } ); } } </del> private onAddFoldersRequest(request: IAddFoldersRequest): void { // Buffer all pending requests


import { IStorageService, StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js'; import { INotificationService } from '../../../../platform/notification/common/notification.js'; import { IExtensionService } from '../../../services/extensions/common/extensions.js'; <ins> import { groupBy as groupBy2 } from '../../../../base/common/collections.js'; </ins> const PICK_REPOSITORY_ACTION_ID = 'workbench.scm.action.graph.pickRepository'; const PICK_HISTORY_ITEM_REFS_ACTION_ID = 'workbench.scm.action.graph.pickHistoryItemRefs';


if (exitCode) { this._xterm.writeln(exitCodeMessage); } <del> let message = typeof this._shellLaunchConfig.waitOnExit === 'string' ? this._shellLaunchConfig.waitOnExit : nls.localize('terminal.integrated.waitOnExit', 'Press any key to close the terminal'); // Bold the message and add an extra new line to make it stand out from the rest of the output message = `nx1b[1m${message}x1b[0m`; this._xterm.writeln(message); </del> <ins> if (typeof this._shellLaunchConfig.waitOnExit === 'string') { let message = this._shellLaunchConfig.waitOnExit; // Bold the message and add an extra new line to make it stand out from the rest of the output message = `nx1b[1m${message}x1b[0m`; this._xterm.writeln(message); } </ins> // Disable all input if the terminal is exiting and listen for next keypress this._xterm.setOption('disableStdin', true); if (this._xterm.textarea) {


.monaco-editor .view-ruler { position: absolute; top: 0; <ins> --box-shadow-color: rgba(0, 0, 0, 0); box-shadow: 1px 0 0 0 var(--box-shadow-color) inset; </ins> }  No newline at end of file


cursor: pointer; color: white; flex: 1; <ins> white-space: nowrap; overflow: hidden; } .colorpicker-header .picked-color .picked-color-presentation { white-space: nowrap; margin-left: 5px; margin-right: 5px; </ins> } .colorpicker-header .picked-color .codicon { color: inherit; font-size: 14px; <del> position: absolute; left: 8px; </del> } .colorpicker-header .picked-color.light {


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


markdownDescription: localize('terminal.integrated.accessibleViewPreserveCursorPosition', "Preserve the cursor position on reopen of the terminal's accessible view rather than setting it to the bottom of the buffer."), type: 'boolean', default: false <del> } </del> <ins> }, [TerminalSettingId.AccessibleViewFocusOnCommandExecution]: { markdownDescription: localize('terminal.integrated.accessibleViewFocusOnCommandExecution', "Focus the terminal accessible view when a command is executed."), type: 'boolean', default: false }, </ins> } };


import { IQuickPickSeparator } from 'vs/platform/quickinput/common/quickInput'; import { IViewsService } from 'vs/workbench/common/views'; import { DEBUG_CONSOLE_QUICK_ACCESS_PREFIX, SELECT_AND_START_ID } from 'vs/workbench/contrib/debug/browser/debugCommands'; <del> import { getStateLabel, IDebugService, IDebugSession, REPL_VIEW_ID } from 'vs/workbench/contrib/debug/common/debug'; </del> <ins> import { IDebugService, IDebugSession, REPL_VIEW_ID } from 'vs/workbench/contrib/debug/common/debug'; </ins> export class DebugConsoleQuickAccess extends PickerQuickAccessProvider<IPickerQuickAccessItem> {


}; } <del> function slugFromHeading(heading: string): string { </del> <ins> function addLinkRenderer(md: MarkdownIt): void { const original = md.renderer.rules.link_open; md.renderer.rules.link_open = (tokens: MarkdownItToken[], idx: number, options, env, self) => { const token = tokens[idx]; const href = token.attrGet('href'); if (typeof href === 'string' && href.startsWith('#')) { token.attrSet('href', '#' + slugify(href.slice(1))); } if (original) { return original(tokens, idx, options, env, self); } else { return self.renderToken(tokens, idx, options); } }; } function slugify(text: string): string { </ins> const slugifiedHeading = encodeURI( <del> heading.trim() </del> <ins> text.trim() </ins> .toLowerCase() .replace(/s+/g, '-') // Replace whitespace with - // allow-any-unicode-next-line


); } <del> async cloneRepository(url?: string, parentPath?: string, options: { recursive?: boolean } = {}): Promise<void> { </del> <ins> async cloneRepository(url?: string, parentPath?: string, options: { recursive?: boolean; ref?: string } = {}): Promise<void> { </ins> if (!url || typeof url !== 'string') { url = await pickRemoteSource({ providerLabel: provider => localize('clonefrom', "Clone from {0}", provider.name),


const NOTEBOOK_FIND_IN_CODE_INPUT = nls.localize('notebook.find.filter.findInCodeInput', "Code Cell Source"); const NOTEBOOK_FIND_IN_CODE_OUTPUT = nls.localize('notebook.find.filter.findInCodeOutput', "Code Cell Output"); <del> const NOTEBOOK_FIND_WIDGET_INITIAL_WIDTH = 318; </del> <ins> const NOTEBOOK_FIND_WIDGET_INITIAL_WIDTH = 419; </ins> const NOTEBOOK_FIND_WIDGET_INITIAL_HORIZONTAL_PADDING = 4; class NotebookFindFilterActionViewItem extends DropdownMenuActionViewItem { constructor(readonly filters: NotebookFindFilters, action: IAction, options: IActionViewItemOptions, actionRunner: IActionRunner, @IContextMenuService contextMenuService: IContextMenuService) {


export const USER_DATA_SYNC_SCHEME = 'vscode-userdata-sync'; export const PREVIEW_DIR_NAME = 'preview'; <ins> export const EXTENSIONS_SYNC_CONTEXT_KEY = 'extensionsSync'; </ins>


} } <del> function getReportIssueArgsForError(error: TypeScriptServerError): { issueTitle: string, issueBody: string } | undefined { </del> <ins> function getReportIssueArgsForError(error: TypeScriptServerError): { extensionId: string, issueTitle: string, issueBody: string } | undefined { </ins> if (!error.serverStack || !error.serverMessage) { return undefined; }


async updateLocalExtensions(added: ISyncExtension[], removed: IExtensionIdentifier[], updated: ISyncExtension[], skippedExtensions: ISyncExtension[], profile: IUserDataProfile): Promise<ISyncExtension[]> { const syncResourceLogLabel = getSyncResourceLogLabel(SyncResource.Extensions, profile); <del> return this.withProfileScopedServices(profile, async (extensionEnablementService, extensionStorageService) => { const removeFromSkipped: IExtensionIdentifier[] = []; const addToSkipped: ISyncExtension[] = []; const installedExtensions = await this.extensionManagementService.getInstalled(undefined, profile.extensionsResource); if (removed.length) { const extensionsToRemove = installedExtensions.filter(({ identifier, isBuiltin }) => !isBuiltin && removed.some(r => areSameExtensions(identifier, r))); await Promises.settled(extensionsToRemove.map(async extensionToRemove => { this.logService.trace(`${syncResourceLogLabel}: Uninstalling local extension...`, extensionToRemove.identifier.id); await this.extensionManagementService.uninstall(extensionToRemove, { donotIncludePack: true, donotCheckDependents: true, profileLocation: profile.extensionsResource }); this.logService.info(`${syncResourceLogLabel}: Uninstalled local extension.`, extensionToRemove.identifier.id); removeFromSkipped.push(extensionToRemove.identifier); })); } </del> <ins> const extensionsToInstall: [ISyncExtension, IGalleryExtension][] = []; const removeFromSkipped: IExtensionIdentifier[] = []; const addToSkipped: ISyncExtension[] = []; const installedExtensions = await this.extensionManagementService.getInstalled(undefined, profile.extensionsResource); </ins> <del> if (added.length || updated.length) { </del> <ins> // 1. Sync extensions state first so that the storage is flushed and updated in all opened windows if (added.length || updated.length) { await this.withProfileScopedServices(profile, async (extensionEnablementService, extensionStorageService) => { </ins> await Promises.settled([...added, ...updated].map(async e => { const installedExtension = installedExtensions.find(installed => areSameExtensions(installed.identifier, e.identifier));


id: 'editor.action.toggleScreenReaderAccessibilityMode', title: { value: nls.localize('toggleScreenReaderMode', "Toggle Screen Reader Accessibility Mode"), original: 'Toggle Screen Reader Accessibility Mode' }, f1: true, <ins> keybinding: { primary: KeyMod.CtrlCmd | KeyCode.KeyE, weight: KeybindingWeight.WorkbenchContrib + 10, when: accessibilityHelpIsShown } </ins> }); }


override async revealRangeInCenterIfOutsideViewportAsync() { } override async layoutNotebookCell() { } override async removeInset() { } <del> override async focusNotebookCell() { } </del> <ins> override async focusNotebookCell(cell: ICellViewModel, focusItem: 'editor' | 'container' | 'output') { cell.focusMode = focusItem === 'editor' ? CellFocusMode.Editor : focusItem === 'output' ? CellFocusMode.Output : CellFocusMode.Container; } </ins> override cellAt(index: number) { return viewModel.cellAt(index)!; } override getCellIndex(cell: ICellViewModel) { return viewModel.getCellIndex(cell); } override getCellsInRange(range?: ICellRange) { return viewModel.getCellsInRange(range); }


CannotEndIn = 2 } <del> var getCharacterClasses = (function() { var FORCE_TERMINATION_CHARACTERS = ' t<>'"'; var CANNOT_END_WITH_CHARACTERS = '.,;'; var _cachedResult: CharacterClass[] = null; var findLargestCharCode = (str:string):number => { var r = 0; for (var i = 0, len = str.length; i < len; i++) { r = Math.max(r, str.charCodeAt(i)); </del> <ins> let _openParens = '('.charCodeAt(0); let _closeParens = ')'.charCodeAt(0); let _openSquareBracket = '['.charCodeAt(0); let _closeSquareBracket = ']'.charCodeAt(0); let _openCurlyBracket = '{'.charCodeAt(0); let _closeCurlyBracket = '}'.charCodeAt(0); class CharacterClassifier { /** * Maintain a compact (fully initialized ASCII map for quickly classifying ASCII characters - used more often in code). */ private _asciiMap: CharacterClass[]; /** * The entire map (sparse array). */ private _map: CharacterClass[]; constructor() { var FORCE_TERMINATION_CHARACTERS = ' t<>'"、。｡､，．：；？！＠＃＄％＆＊‘“〈《「『【〔（［｛｢｣｝］）〕】』」》〉”’｀～…'; var CANNOT_END_WITH_CHARACTERS = '.,;'; this._asciiMap = []; for (let i = 0; i < 256; i++) { this._asciiMap[i] = CharacterClass.None; </ins> } <del> return r; }; var set = (str:string, toWhat:CharacterClass): void => { for (var i = 0, len = str.length; i < len; i++) { _cachedResult[str.charCodeAt(i)] = toWhat; </del> <ins> this._map = []; for (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) { this._set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), CharacterClass.ForceTermination); </ins> } <del> }; return function(): CharacterClass[] { if (_cachedResult === null) { // Find cachedResult size var largestCharCode = Math.max( findLargestCharCode(FORCE_TERMINATION_CHARACTERS), findLargestCharCode(CANNOT_END_WITH_CHARACTERS) ); // Initialize cachedResult _cachedResult = []; for (var i = 0; i < largestCharCode; i++) { _cachedResult[i] = CharacterClass.None; } // Fill in cachedResult set(FORCE_TERMINATION_CHARACTERS, CharacterClass.ForceTermination); set(CANNOT_END_WITH_CHARACTERS, CharacterClass.CannotEndIn); </del> <ins> for (let i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) { this._set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), CharacterClass.CannotEndIn); } } private _set(charCode:number, charClass:CharacterClass): void { if (charCode < 256) { this._asciiMap[charCode] = charClass; </ins> } <ins> this._map[charCode] = charClass; } </ins> <del> return _cachedResult; }; })(); </del> <ins> public classify(charCode:number): CharacterClass { if (charCode < 256) { return this._asciiMap[charCode]; } </ins> <del> let _openParens = '('.charCodeAt(0); let _closeParens = ')'.charCodeAt(0); let _openSquareBracket = '['.charCodeAt(0); let _closeSquareBracket = ']'.charCodeAt(0); let _openCurlyBracket = '{'.charCodeAt(0); let _closeCurlyBracket = '}'.charCodeAt(0); </del> <ins> let charClass = this._map[charCode]; if (charClass) { return charClass; } return CharacterClass.None; } } </ins> class LinkComputer {


return TerminalInstance._lastKnownCanvasDimensions; } <del> set shutdownPersistentProcessId(shutdownPersistentProcessId: number | undefined) { this._shutdownPersistentProcessId = shutdownPersistentProcessId; } get persistentProcessId(): number | undefined { return this._processManager.persistentProcessId ?? this._shutdownPersistentProcessId; } get shouldPersist(): boolean { return (this._processManager.shouldPersist || this._shutdownPersistentProcessId !== undefined) && !this.shellLaunchConfig.isTransient && (!this.reconnectionProperties || this._configurationService.getValue(TaskSettingId.Reconnection) === true); } </del> <ins> get persistentProcessId(): number | undefined { return this._processManager.persistentProcessId; } get shouldPersist(): boolean { return this._processManager.shouldPersist && !this.shellLaunchConfig.isTransient && (!this.reconnectionProperties || this._configurationService.getValue(TaskSettingId.Reconnection) === true); } </ins> /** * Create xterm.js instance and attach data listeners.


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ import { Disposable, IDisposable } from 'vs/base/common/lifecycle'; import { isDiffEditor } from 'vs/editor/browser/editorBrowser'; import { localize } from 'vs/nls'; import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { IWorkbenchContribution } from 'vs/workbench/common/contributions'; import { IEditorService } from 'vs/workbench/services/editor/common/editorService'; import { Event } from 'vs/base/common/event'; import { AccessibilityVerbositySettingId } from 'vs/workbench/contrib/accessibility/browser/accessibilityConfiguration'; export class DiffEditorActiveAnnouncementContribution extends Disposable implements IWorkbenchContribution { static readonly ID = 'workbench.contrib.diffEditorActiveAnnouncement'; private _onDidActiveEditorChangeListener?: IDisposable; constructor( @IEditorService private readonly _editorService: IEditorService, @IAccessibilityService private readonly _accessibilityService: IAccessibilityService, @IConfigurationService private readonly _configurationService: IConfigurationService ) { super(); this._register(Event.runAndSubscribe(_accessibilityService.onDidChangeScreenReaderOptimized, () => this._updateListener())); this._register(_configurationService.onDidChangeConfiguration(e => { if (e.affectsConfiguration(AccessibilityVerbositySettingId.DiffEditorActive)) { this._updateListener(); } })); } private _updateListener(): void { const announcementEnabled = this._configurationService.getValue(AccessibilityVerbositySettingId.DiffEditorActive); const screenReaderOptimized = this._accessibilityService.isScreenReaderOptimized(); if (!announcementEnabled || !screenReaderOptimized) { this._onDidActiveEditorChangeListener?.dispose(); this._onDidActiveEditorChangeListener = undefined; return; } if (this._onDidActiveEditorChangeListener) { return; } this._onDidActiveEditorChangeListener = this._register(this._editorService.onDidActiveEditorChange(() => { if (isDiffEditor(this._editorService.activeTextEditorControl)) { this._accessibilityService.alert(localize('openDiffEditorAnnouncement', "Diff editor")); } })); } } </ins>


configHelper: ITerminalConfigHelper, shellLaunchConfig: IShellLaunchConfig ): ITerminalInstance { <ins> const newTerminalSize = ((this._panelPosition === Position.BOTTOM ? this._container.clientWidth : this._container.clientHeight) / (this._terminalInstances.length + 1)); if (newTerminalSize < TERMINAL_MIN_USEFUL_SIZE) { return undefined; } </ins> const instance = this._terminalService.createInstance( terminalFocusContextKey, configHelper,


*--------------------------------------------------------------------------------------------*/ .accessible-view { <del> position: relative; </del> <ins> position: absolute; </ins> background-color: var(--vscode-editorWidget-background); color: var(--vscode-editorWidget-foreground); box-shadow: 0 2px 8px var(--vscode-widget-shadow); <del> border: 2px solid var(--vscode-contrastActiveBorder); </del> <ins> border: 2px solid var(--vscode-focusBorder); </ins> }


// Use the repository real path const repoPathRealPath = await fs.promises.realpath(repoPath, { encoding: 'utf8' }); const openRepositoryRealPath = this.openRepositories <del> .find(r => pathEquals(r.repository.rootRealPath ?? '', repoPathRealPath)); </del> <ins> .find(r => pathEquals(r.repository.rootRealPath ?? r.repository.root, repoPathRealPath)); </ins> return openRepositoryRealPath?.repository; } catch (err) {


createPreferencesEditorModel<T>(uri: URI): TPromise<IPreferencesEditorModel<T>>; openRawDefaultSettings(): TPromise<void>; <ins> openRawUserSettings(): TPromise<void>; </ins> openSettings(): TPromise<IEditor>; openSettings2(): TPromise<IEditor>; openGlobalSettings(options?: IEditorOptions, position?: Position): TPromise<IEditor>;


import { webFrame } from 'electron'; import { assign } from 'vs/base/common/objects'; import { IWorkbenchIssueService } from 'vs/workbench/contrib/issue/electron-browser/issue'; <del> import { ExtensionType } from 'vs/platform/extensions/common/extensions'; </del> import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService'; import { INativeWorkbenchEnvironmentService } from 'vs/workbench/services/environment/electron-browser/environmentService'; <ins> import { ExtensionType } from 'vs/platform/extensions/common/extensions'; </ins> export class WorkbenchIssueService implements IWorkbenchIssueService { _serviceBrand: undefined;


box-sizing: border-box; height: 100%; width: 100%; <ins> padding-right: 22px; </ins> } .monaco-editor .suggest-widget .details > .monaco-scrollable-element > .body > .header > .type {


'editor.trimAutoWhitespace', 'editor.folding', 'workbench.editor.enablePreviewFromQuickOpen', <ins> 'php.builtInCompletions.enable', </ins> 'php.validate.enable', <ins> 'php.validate.run', </ins> 'editor.parameterHints', ];


italic: register('italic', 0xeb0d), jersey: register('jersey', 0xeb0e), json: register('json', 0xeb0f), <ins> bracket: register('bracket', 0xeb0f), </ins> kebabVertical: register('kebab-vertical', 0xeb10), key: register('key', 0xeb11), law: register('law', 0xeb12),


if (editorGutterModifiedBackgroundColor) { collector.addRule(` .monaco-editor .dirty-diff-modified { <del> background-size: 3px 4.5px; </del> background-repeat-x: no-repeat; background-image: linear-gradient(${linearGradient}); transition: opacity 0.5s;


result = result || MouseTargetFactory._hitTestMargin(ctx, resolvedRequest); result = result || MouseTargetFactory._hitTestViewCursor(ctx, resolvedRequest); result = result || MouseTargetFactory._hitTestTextArea(ctx, resolvedRequest); <del> result = result || MouseTargetFactory._hitTestViewLines(ctx, resolvedRequest, domHitTestExecuted); </del> <ins> result = result || MouseTargetFactory._hitTestViewLines(ctx, resolvedRequest); </ins> result = result || MouseTargetFactory._hitTestScrollbar(ctx, resolvedRequest); return (result || request.fulfillUnknown());


/** * An optional validation message indicating a problem with the current input value. */ <del> validationMessage: string | undefined; </del> <ins> validationMessage: string | InputBoxValidationMessage | undefined; </ins> } /**


store.add(this.registerDefaultParticipantView(providerDescriptor)); } <del> if (providerDescriptor.when && !isProposedApiEnabled(extension.description, 'chatParticipantAdditions')) { this.logService.error(`Extension '${extension.description.identifier.value}' CANNOT use API proposal: chatParticipantAdditions.`); continue; } </del> store.add(this._chatAgentService.registerAgent( providerDescriptor.id, {


rows: number; data: string; } <ins> const enum Constants { /** * Writing large amounts of data can be corrupted for some reason, after looking into this is * appears to be a race condition around writing to the FD which may be based on how powerful * the hardware is. The workaround for this is to space out when large amounts of data is being * written to the terminal. See https://github.com/microsoft/vscode/issues/38137 */ WriteMaxChunkSize = 50, } /** * Splits incoming pty data into chunks to try prevent data corruption that could occur when pasting * large amounts of data. */ export function chunkInput(data: string): string[] { const chunks: string[] = []; let nextChunkStartIndex = 0; for (let i = 0; i < data.length - 1; i++) { if ( // If the max chunk size is reached i - nextChunkStartIndex + 1 >= Constants.WriteMaxChunkSize || // If the next character is ESC, send the pending data to avoid splitting the escape // sequence. data[i + 1] === 'x1b' ) { chunks.push(data.substring(nextChunkStartIndex, i + 1)); nextChunkStartIndex = i + 1; // Skip the next character as the chunk would be a single character i++; } } // Push final chunk if (nextChunkStartIndex !== data.length) { chunks.push(data.substring(nextChunkStartIndex)); } return chunks; } </ins>


'description': nls.localize('zoomLevel', "Adjust the zoom level of the window. The original size is 0 and each increment above or below represents zooming 20% larger or smaller.") } } <ins> }); // Configuration: Update configurationRegistry.registerConfiguration({ 'id': 'update', 'order': 10, 'title': nls.localize('updateConfigurationTitle', "Update configuration"), 'type': 'object', 'properties': { 'update.channel': { 'type': 'string', 'enum': ['none', 'default'], 'default': 'default', 'description': nls.localize('updateChannel', "Configure the update channel to receive updates from. Requires a restart after change.") } } </ins> });  No newline at end of file


*/ static parse(value: string, _strict: boolean = false): URI { const match = _regexp.exec(value); <del> if (!match) { return new _URI(_empty, _empty, _empty, _empty, _empty); </del> <ins> if (match) { return new _URI( match[2] || _empty, decodeURIComponent(match[4] || _empty), decodeURIComponent(match[5] || _empty), decodeURIComponent(match[7] || _empty), decodeURIComponent(match[9] || _empty), _strict ); </ins> } <del> return new _URI( match[2] || _empty, decodeURIComponent(match[4] || _empty), decodeURIComponent(match[5] || _empty), decodeURIComponent(match[7] || _empty), decodeURIComponent(match[9] || _empty), _strict ); </del> <ins> return new _URI(_empty, _empty, _empty, _empty, _empty); </ins> } /**


id: TerminalCommandId.ConfigureTerminalSettings, title: localize('workbench.action.terminal.openSettings', "Configure Terminal Settings") }, <del> group: TerminalTabContextMenuGroup.Configure </del> <ins> group: '3_configure' </ins> } <ins> }, { id: MenuId.TerminalNewDropdownContext, item: { command: { id: 'workbench.action.tasks.runTask', title: localize('workbench.action.tasks.runTask', "Run Task...") }, when: TaskExecutionSupportedContext, group: '4_tasks', order: 1 }, }, { id: MenuId.TerminalNewDropdownContext, item: { command: { id: 'workbench.action.tasks.configureTaskRunner', title: localize('workbench.action.tasks.configureTaskRunner', "Configure Tasks...") }, when: TaskExecutionSupportedContext, group: '4_tasks', order: 2 }, </ins> } ] );


this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/install_extension/accept', { extensionId: extensionIdentifier.id }); try { <del> await this.progressService.withProgress({ </del> <ins> extension = await this.progressService.withProgress({ </ins> location: ProgressLocation.Notification, title: localize('Installing', "Installing Extension '{0}'...", galleryExtension.displayName || galleryExtension.name) }, () => this.extensionManagementService.installFromGallery(galleryExtension!)); <del> this.notificationService.prompt( Severity.Info, localize('reload', "Would you like to reload the window and open the URL '{0}'?", uri.toString()), [{ label: localize('Reload', "Reload Window and Open"), run: async () => { this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/install_extension/reload', { extensionId: extensionIdentifier.id }); await this.reloadAndHandle(uri); } }], { sticky: true } ); </del> } catch (error) { this.notificationService.error(error); <ins> return; } } // Extension is installed but not enabled if (!this.extensionEnablementService.isEnabled(extension)) { this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/enable_extension/start', { extensionId: extensionIdentifier.id }); const result = await this.dialogService.confirm({ message: localize('enableAndHandle', "Extension '{0}' is disabled. Would you like to enable the extension and open the URL?", extension.manifest.displayName || extension.manifest.name), detail: `${extension.manifest.displayName || extension.manifest.name} (${extensionIdentifier.id}) wants to open a URL:nn${uri.toString()}`, primaryButton: localize('enableAndReload', "&&Enable and Open"), type: 'question' }); if (!result.confirmed) { this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/enable_extension/cancel', { extensionId: extensionIdentifier.id }); return; </ins> } <ins> this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/enable_extension/accept', { extensionId: extensionIdentifier.id }); await this.extensionEnablementService.setEnablement([extension], EnablementState.EnabledGlobally); } if (this.extensionService.canAddExtension(toExtensionDescription(extension))) { await this.waitUntilExtensionIsAdded(extensionIdentifier); await this.handleURL(uri, { ...options, trusted: true }); } /* Extension cannot be added and require window reload */ else { this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/activate_extension/start', { extensionId: extensionIdentifier.id }); const result = await this.dialogService.confirm({ message: localize('reloadAndHandle', "Extension '{0}' is not loaded. Would you like to reload the window to load the extension and open the URL?", extension.manifest.displayName || extension.manifest.name), detail: `${extension.manifest.displayName || extension.manifest.name} (${extensionIdentifier.id}) wants to open a URL:nn${uri.toString()}`, primaryButton: localize('reloadAndOpen', "&&Reload Window and Open"), type: 'question' }); if (!result.confirmed) { this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/activate_extension/cancel', { extensionId: extensionIdentifier.id }); return; } this.telemetryService.publicLog2<ExtensionUrlHandlerEvent, ExtensionUrlHandlerClassification>('uri_invoked/activate_extension/accept', { extensionId: extensionIdentifier.id }); this.storageService.store(URL_TO_HANDLE, JSON.stringify(uri.toJSON()), StorageScope.WORKSPACE, StorageTarget.MACHINE); await this.hostService.reload(); </ins> } } <del> private async reloadAndHandle(url: URI): Promise<void> { this.storageService.store(URL_TO_HANDLE, JSON.stringify(url.toJSON()), StorageScope.WORKSPACE, StorageTarget.MACHINE); await this.hostService.reload(); </del> <ins> private async waitUntilExtensionIsAdded(extensionId: IExtensionIdentifier): Promise<void> { if (!(await this.extensionService.getExtension(extensionId.id))) { await new Promise<void>((c, e) => { const disposable = this.extensionService.onDidChangeExtensions(async () => { try { if (await this.extensionService.getExtension(extensionId.id)) { disposable.dispose(); c(); } } catch (error) { e(error); } }); }); } </ins> } // forget about all uris buffered more than 5 minutes ago


this.contextKeyService = service; } <del> private getActions(menuId: MenuId, element: ITreeItem, listen: boolean = false): { menu?: IMenu; primary: IAction[]; secondary: IAction[] } { </del> <ins> private getActions(menuId: MenuId, element: ITreeItem, listen?: DisposableStore): { menu?: IMenu; primary: IAction[]; secondary: IAction[] } { </ins> if (!this.contextKeyService) { return { primary: [], secondary: [] }; }


} const instance = tab.split(this._terminalFocusContextKey, this.configHelper, shellLaunchConfig); <del> this._initInstanceListeners(instance); this._onInstancesChanged.fire(); </del> <ins> if (instance) { this._initInstanceListeners(instance); this._onInstancesChanged.fire(); </ins> <del> this._terminalTabs.forEach((t, i) => t.setVisible(i === this._activeTabIndex)); </del> <ins> this._terminalTabs.forEach((t, i) => t.setVisible(i === this._activeTabIndex)); } else { this._showNotEnoughSpaceToast(); } </ins> } protected _initInstanceListeners(instance: ITerminalInstance): void {


import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions, IWorkbenchContribution } from 'vs/workbench/common/contributions'; import { Registry } from 'vs/platform/registry/common/platform'; import { LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle'; <del> import { Action2, IAction2Options, registerAction2 } from 'vs/platform/actions/common/actions'; </del> <ins> import { Action2, IAction2Options, MenuRegistry, registerAction2 } from 'vs/platform/actions/common/actions'; </ins> import { ServicesAccessor } from 'vs/editor/browser/editorExtensions'; import { localize } from 'vs/nls'; import { IEditSessionsWorkbenchService, Change, ChangeType, Folder, EditSession, FileType, EDIT_SESSION_SYNC_CATEGORY, EDIT_SESSIONS_CONTAINER_ID, EditSessionSchemaVersion, IEditSessionsLogService, EDIT_SESSIONS_VIEW_ICON, EDIT_SESSIONS_TITLE, EDIT_SESSIONS_SHOW_VIEW, EDIT_SESSIONS_SIGNED_IN, EDIT_SESSIONS_DATA_VIEW_ID, decodeEditSessionFileContent } from 'vs/workbench/contrib/editSessions/common/editSessions'; import { ISCMRepository, ISCMService } from 'vs/workbench/contrib/scm/common/scm'; import { IFileService } from 'vs/platform/files/common/files'; <del> import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace'; </del> <ins> import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace'; </ins> import { URI } from 'vs/base/common/uri'; import { joinPath, relativePath } from 'vs/base/common/resources'; import { encodeBase64 } from 'vs/base/common/buffer';


css += `.monaco-workbench .panel.integrated-terminal .terminal-outer-container { background-color: ${bgColor}; }`; } const fgColor = theme.getColor(TERMINAL_FOREGROUND_COLOR); <del> if (bgColor) { </del> <ins> if (fgColor) { </ins> css += `.monaco-workbench .panel.integrated-terminal .xterm { color: ${fgColor}; }`; }


} public set scrollTop(scrollTop: number) { <ins> const horizontalScrollHeight = this.horizontalScrolling ? 10 : 0; </ins> this.scrollableElement.setScrollDimensions({ <del> scrollHeight: this.getContentHeight() </del> <ins> scrollHeight: this.getContentHeight() + horizontalScrollHeight </ins> }); this.scrollableElement.setScrollPosition({ scrollTop: scrollTop


function fish_mode_prompt __vsc_fish_prompt_start __vsc_fish_mode_prompt <ins> __vsc_fish_cmd_start </ins> end function fish_prompt __vsc_fish_prompt <del> __vsc_fish_cmd_start </del> end else # No fish_mode_prompt, so put everything in fish_prompt.


import { SnippetController2 } from 'vs/editor/contrib/snippet/snippetController2'; import { IMenuService, IMenu } from 'vs/platform/actions/common/actions'; import { createTextModel } from 'vs/editor/test/common/editorTestUtils'; <ins> import { Range } from 'vs/editor/common/core/range'; import { timeout } from 'vs/base/common/async'; </ins> suite('SuggestController', function () {


// enable signing of commits if configurated opts.signCommit = enableCommitSigning; <ins> if (config.get<boolean>('alwaysSignOff')) { opts.signoff = true; } </ins> if ( // no changes (noStagedChanges && noUnstagedChanges)


} export interface MainThreadProfileContentHandlersShape { <del> $registerProfileContentHandler(id: string, name: string, extensionId: string): Promise<void>; </del> <ins> $registerProfileContentHandler(id: string, name: string, description: string | undefined, extensionId: string): Promise<void>; </ins> $unregisterProfileContentHandler(id: string): Promise<void>; }


}, "dependencies": { "@vscode/extension-telemetry": "0.5.1", <del> "vscode-languageclient": "^8.0.1", </del> <ins> "vscode-languageclient": "^8.0.2-next.4", </ins> "vscode-nls": "^5.0.1", "vscode-uri": "^3.0.3" },


viewState: ISettingsEditorViewState, settingsOrderByTocIndex: Map<string, number> | null, isWorkspaceTrusted: boolean, <del> @IWorkbenchConfigurationService private readonly configurationService: IWorkbenchConfigurationService, </del> <ins> @IWorkbenchConfigurationService configurationService: IWorkbenchConfigurationService, </ins> @IWorkbenchEnvironmentService private readonly environmentService: IWorkbenchEnvironmentService, @ILanguageService languageService: ILanguageService, @IUserDataProfileService userDataProfileService: IUserDataProfileService,


import { EditorOption } from 'vs/editor/common/config/editorOptions'; import * as platform from 'vs/base/common/platform'; import { MenuRegistry } from 'vs/platform/actions/common/actions'; <ins> import { CancellationTokenSource } from 'vs/base/common/cancellation'; </ins> // sticky suggest widget which doesn't disappear on focus out and such let _sticky = false;


if (highlights) { return { label, <del> description: getStateLabel(session.state), </del> highlights: { label: highlights }, accept: (keyMod, event) => { this._debugService.focusStackFrame(undefined, undefined, session, { explicit: true });


private _shouldFocus: boolean; private _colorPicker: ColorPickerWidget | null; private _renderDisposable: IDisposable | null; <ins> private _preferBelow: boolean; </ins> constructor( editor: ICodeEditor,


import { ICommandService } from 'vs/platform/commands/common/commands'; import { ContextKeyExpr, ContextKeyExpression, IContextKeyService, RawContextKey } from 'vs/platform/contextkey/common/contextkey'; import { Disposable } from 'vs/base/common/lifecycle'; <del> import { IUserDataSyncEnablementService } from 'vs/platform/userDataSync/common/userDataSync'; </del> <ins> import { EXTENSIONS_SYNC_CONTEXT_KEY, IUserDataSyncEnablementService } from 'vs/platform/userDataSync/common/userDataSync'; </ins> import { IExtensionDescription } from 'vs/platform/extensions/common/extensions'; import { URI } from 'vs/base/common/uri'; import { joinPath } from 'vs/base/common/resources';


} // Save selection <del> const selection = this.widget?.getSelection(); </del> <ins> const selection = new Set<Marker>(); for (const marker of this.widget.getSelection()) { if (marker instanceof ResourceMarkers) { marker.markers.forEach(m => selection.add(m)); } else if (marker instanceof Marker || marker instanceof MarkerTableItem) { selection.add(marker); } } // Save focus const focus = new Set<Marker>(); for (const marker of this.widget.getFocus()) { if (marker instanceof Marker || marker instanceof MarkerTableItem) { focus.add(marker); } } </ins> // Create new widget this.createWidget(this.widgetContainer); this.refreshPanel(); // Restore selection <del> if (selection && selection.length > 0 && (selection[0] instanceof Marker || selection[0] instanceof MarkerTableItem)) { </del> <ins> if (selection.size > 0) { this.widget.setMarkerSelection(Array.from(selection), Array.from(focus)); </ins> this.widget.domFocus(); <del> this.widget.setMarkerSelection(selection[0]); </del> } }


iconClass: ThemeIcon.asClassName(searchOpenInFileIcon), tooltip: localize('QuickSearchOpenInFile', "Open File") }], <ins> trigger: async (): Promise<TriggerAction> => { await this.handleAccept(fileMatch, {}); return TriggerAction.CLOSE_PICKER; }, </ins> }); const results: Match[] = fileMatch.matches() ?? [];


"filenames": [ "git-rebase-todo" ], <ins> "filenamePatterns": [ "**/rebase-merge/done" ], </ins> "configuration": "./languages/git-rebase.language-configuration.json" }, {


const href = a.getAttribute('data-href'); if (href) { if (href.startsWith(variableRefUrl)) { <del> const title = href.slice(variableRefUrl.length); </del> <ins> const title = decodeURIComponent(href.slice(variableRefUrl.length)); </ins> a.parentElement!.replaceChild( renderResourceWidget(a.textContent!, title), a);


const content = model.main; if (!input.resource.path.endsWith('.md')) { <del> safeInnerHtml(this.content, content); </del> <ins> safeInnerHtml(this.content, content, { ALLOW_UNKNOWN_PROTOCOLS: true }); </ins> this.updateSizeClasses(); this.decorateContent();


<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-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="M12.632,8A4.632,4.632,0,1,1,8,3.368,4.638,4.638,0,0,1,12.632,8Z"/></g><g id="iconBg"><path class="icon-disabled-grey" d="M8,4.211A3.789,3.789,0,1,0,11.789,8,3.788,3.788,0,0,0,8,4.211ZM8,10.79A2.79,2.79,0,1,1,10.79,8,2.794,2.794,0,0,1,8,10.79Z"/></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-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="M12.632,8A4.632,4.632,0,1,1,8,3.368,4.638,4.638,0,0,1,12.632,8Z"/></g><g id="iconBg"><path class="icon-disabled-grey" d="M8,4.211A3.789,3.789,0,1,0,11.79,8,3.788,3.788,0,0,0,8,4.211ZM8,10.29A2.29,2.29,0,1,1,10.29,8,2.292,2.292,0,0,1,8,10.29Z"/></g></svg> </ins>  No newline at end of file


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


resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.207.tgz#9c3310ebace2952903d05dcaba8abe3a4ed44c01" integrity sha512-piH7MJDJp4rJCduWbVvmUd59AUne1AFBJ8JaRQvk0KzNTSUnZrVXHCZc+eg+CGE4OujkcLJznhGKD6tuAshj5Q== <del> electron@22.3.5: version "22.3.5" resolved "https://registry.yarnpkg.com/electron/-/electron-22.3.5.tgz#a53a318cbb25a44914dfedd30a9ad6120632197f" integrity sha512-CTdnoTbO3sDiMv47TX3ZO640Ca57v1qpiqGChFF8oZbtfHuQjTPPaE4hsoynf22wwnBiyJNL41DpB/pfp9USnA== </del> <ins> electron@22.3.6: version "22.3.6" resolved "https://registry.yarnpkg.com/electron/-/electron-22.3.6.tgz#ab79a2da20e83b02ec9cbb22a4069468e6949b4f" integrity sha512-/1/DivFHH5AWa/uOuqpkeg12/jjicjkBU8kYv70oeqRFwXzoyuJhgwlzER4jZXnbGjF5Nxz9900oXq/QzAViAw== </ins> dependencies: "@electron/get" "^2.0.0" "@types/node" "^16.11.26"


accessibleViewService.show({ verbositySettingKey: AccessibilityVerbositySettingId.Chat, <del> provideContent(): string { return responseContent; }, </del> <ins> provideContent(): string { return responseContent!; }, </ins> onClose() { verifiedWidget.reveal(focusedItem); if (chatInputFocused) {


} class BarrierAction extends Action { <del> constructor(barrier: Barrier, action: Action) { </del> <ins> constructor(barrier: Barrier, action: Action, notificationService: INotificationService) { </ins> super(action.id, action.label, action.class, action.enabled, async () => { <del> await action.run(); </del> <ins> try { await action.run(); } catch (error) { notificationService.error(error); throw error; } </ins> barrier.open(); }); }


} return this.addExtensionToWorkspaceConfig(workspaceConfig, extensionId, shouldRecommend).then(() => { <del> this.notificationService.info(localize('AddToWorkspaceUnwantedRecommendations.success', 'The extension was successfully added to this workspace's unwanted recommendations.')); </del> <ins> this.notificationService.prompt(Severity.Info, localize('AddToWorkspaceUnwantedRecommendations.success', 'The extension was successfully added to this workspace's unwanted recommendations.'), [{ label: localize('viewChanges', "View Changes"), run: () => this.openWorkspaceConfigurationFile(workspaceConfig) }]); </ins> }, err => { this.notificationService.error(localize('AddToWorkspaceRecommendations.failure', 'Failed to write. {0}', err)); });


i = wrappedLineStart; lines.unshift(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, cols)); if (!match) { <del> match = lines.join('n').match(matcher); wrappedLines++; </del> <ins> match = lines[0].match(matcher); </ins> } <del> if (wrappedLines >= linesToCheck) { </del> <ins> if (lines.length >= linesToCheck) { </ins> break; } }


ensureNoDisposablesAreLeakedInTestSuite(); <ins> let config: TestConfigurationService; </ins> setup(() => { testDisposables = new DisposableStore(); instantiationService = setupInstantiationService(testDisposables); <del> const config = new TestConfigurationService({ </del> <ins> config = new TestConfigurationService({ </ins> [NotebookSetting.anchorToFocusedCell]: 'auto' }); instantiationService.stub(IConfigurationService, config); });


break; } <ins> // HACK: In order to support both links containing [ and ] characters as well as the // `<file>[<line>, <col>]` pattern, we need to detect the part after the comma and fix // up the link here as before that will be matched as a regular file path. if (link.match(/[d+,$/)) { const partialText = text.slice(rex.lastIndex); const suffixMatch = partialText.match(/^ d+]/); if (suffixMatch) { link += suffixMatch[0]; } } </ins> // Adjust the link range to exclude a/ and b/ if it looks like a git diff if ( // --- a/foo/bar


<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-function-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.7,13H2.3L8,2.741Z"/></g><g id="iconBg"><path class="icon-disabled-grey" d="M8,4.8,4,12h8ZM8,6.859,10.3,11H5.7Z"/></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-function-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.95,13H2.05L8,2.291Z"/></g><g id="iconBg"><path class="icon-disabled-grey" d="M8,4.35,3.75,12h8.5ZM8,6.924l2.125,3.826H5.875Z"/></g></svg> </ins>  No newline at end of file


test('TerminalRenderer.write should fire Terminal.onData', (done) => { const reg1 = window.onDidOpenTerminal(terminal => { reg1.dispose(); <del> const reg2 = terminal.onData(data => { </del> <ins> const reg2 = terminal.onDidWriteData(data => { </ins> assert.equal(data, 'bar'); reg2.dispose(); const reg3 = window.onDidCloseTerminal(() => {


0 : this.viewContext.notebookOptions.getLayoutConfiguration().markdownFoldHintHeight; } <del> updateOptions(e: NotebookOptionsChangeEvent) { </del> <ins> override updateOptions(e: NotebookOptionsChangeEvent) { super.updateOptions(e); </ins> if (e.cellStatusBarVisibility || e.insertToolbarPosition || e.cellToolbarLocation) { this._updateTotalHeight(this._computeTotalHeight()); }


anyOf: [ { type: 'boolean', <del> description: nls.localize('fontLigatures', "Enables/Disables font ligatures."), </del> <ins> description: nls.localize('fontLigatures', "Enables/Disables font ligatures ('calt' and 'liga' font features). Change this to a string for fine-grained control of the 'font-feature-settings' CSS property."), </ins> }, { type: 'string', <del> description: nls.localize('fontFeatureSettings', "Explicit font-feature-settings.") </del> <ins> description: nls.localize('fontFeatureSettings', "Explicit 'font-feature-settings' CSS property. A boolean can be passed instead if one only needs to turn on/off ligatures.") </ins> } ], <del> description: nls.localize('fontLigaturesGeneral', "Configures font ligatures or font features."), </del> <ins> description: nls.localize('fontLigaturesGeneral', "Configures font ligatures or font features. Can be either a boolean to enable/disable ligatures or a string for the value of the CSS 'font-feature-settings' property."), </ins> default: false } );


*/ showConstructors?: boolean; /** <ins> * Show deprecated-suggestions. */ showDeprecated?: boolean; /** </ins> * Show field-suggestions. */ showFields?: boolean;


} <del> export class SuggestInlineCompletions implements InlineCompletionsProvider<InlineCompletionResults> { </del> <ins> export class SuggestInlineCompletions extends Disposable implements InlineCompletionsProvider<InlineCompletionResults> { </ins> private _lastResult?: InlineCompletionResults;


"terminal.ansiBrightMagenta": "#6c71c4", "terminal.ansiBrightCyan": "#93a1a1", "terminal.ansiBrightWhite": "#fdf6e3", <ins> // Set terminal background explicitly, otherwise selection becomes invisible when the // terminal is in the side bar "terminal.background": "#FDF6E3", </ins> // Interactive Playground "walkThrough.embeddedEditorBackground": "#00000014" },


.filter((renderableMatch): renderableMatch is URI => (renderableMatch !== null)); } <del> export function findInFilesCommand(accessor: ServicesAccessor, args: IFindInFilesArgs = {}) { </del> <ins> export async function findInFilesCommand(accessor: ServicesAccessor, _args: IFindInFilesArgs = {}) { </ins> const searchConfig = accessor.get(IConfigurationService).getValue<ISearchConfiguration>().search; <ins> const viewsService = accessor.get(IViewsService); const args: IFindInFilesArgs = {}; if (Object.keys(_args).length !== 0) { // resolve variables in the same way as in // https://github.com/microsoft/vscode/blob/8b76efe9d317d50cb5b57a7658e09ce6ebffaf36/src/vs/workbench/contrib/searchEditor/browser/searchEditorActions.ts#L152-L158 const configurationResolverService = accessor.get(IConfigurationResolverService); const historyService = accessor.get(IHistoryService); const workspaceContextService = accessor.get(IWorkspaceContextService); const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot(Schemas.file); const lastActiveWorkspaceRoot = activeWorkspaceRootUri ? withNullAsUndefined(workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri)) : undefined; for (const entry of Object.entries(_args)) { const name = entry[0]; const value = entry[1]; if (value !== undefined) { (args as any)[name as any] = (typeof value === 'string') ? await configurationResolverService.resolveAsync(lastActiveWorkspaceRoot, value) : value; } } } </ins> const mode = searchConfig.mode; if (mode === 'view') { <del> const viewsService = accessor.get(IViewsService); </del> openSearchView(viewsService, false).then(openedView => { if (openedView) { const searchAndReplaceWidget = openedView.searchAndReplaceWidget;


export interface IAccessibleViewService { readonly _serviceBrand: undefined; show(provider: IAccessibleContentProvider): void; <ins> showAccessibleViewHelp(): void; </ins> next(): void; previous(): void; goToSymbol(): void;


super.render(container); addClass(container, 'switch-terminal'); this._register(attachStylerCallback(this.themeService, { selectBorder }, colors => { <del> container.style.border = colors.selectBorder ? `1px solid ${colors.selectBorder}` : ''; </del> <ins> container.style.borderColor = colors.selectBorder ? `${colors.selectBorder}` : ''; </ins> })); }


// The comments in the regex below use real strings/numbers for better readability, here's // the legend: <del> // - Path = foo // - Row  = 339 // - Col  = 12 </del> <ins> // - Path    = foo // - Row     = 339 // - Col     = 12 // - RowEnd  = 341 // - ColEnd  = 14 </ins> // // These all support single quote ' in the place of " and [] in the place of () const lineAndColumnRegexClauses = [


} if (statWithoutTrailing && statWithoutTrailing.isDirectory) { this.badPath = undefined; <del> // At this point we know it's a directory and can add the trailing path separator if (!this.endsWithSlash(inputUriDirname.path)) { inputUriDirname = resources.addTrailingPathSeparator(inputUriDirname); } </del> <ins> inputUriDirname = this.tryAddTrailingSeparatorToDirectory(inputUriDirname, statWithoutTrailing); </ins> return await this.updateItems(inputUriDirname, false, resources.basename(valueUri)) ? UpdateResult.UpdatedWithTrailing : UpdateResult.Updated; } }


this._storageListener = this._storageService.onDidChangeValue(e => { const shared = e.scope === StorageScope.GLOBAL; if (shared && this._sharedStorageKeysToWatch.has(e.key)) { <del> try { this._proxy.$acceptValue(shared, e.key, this._getValue(shared, e.key)); } catch (error) { // ignore parsing errors that can happen } </del> <ins> this._proxy.$acceptValue(shared, e.key, this._getValue(shared, e.key)); </ins> } }); }


<ins> { "information_for_contributors": [ "This file has been converted from https://github.com/dart-lang/dart-syntax-highlight/blob/master/grammars/dart.json", "If you want to provide a fix or improvement, please create a pull request against the original repository.", "Once accepted there, we are happy to receive an update request." ], "version": "https://github.com/dart-lang/dart-syntax-highlight/commit/65f211722c85e9fdf0aa658d5663e6ccaf2ebe25", "name": "Dart", "scopeName": "source.dart", "patterns": [ { "name": "meta.preprocessor.script.dart", "match": "^(#!.*)$" }, { "name": "meta.declaration.dart", "begin": "^w*b(library|import|part of|part|export)b", "beginCaptures": { "0": { "name": "keyword.other.import.dart" } }, "end": ";", "endCaptures": { "0": { "name": "punctuation.terminator.dart" } }, "patterns": [ { "include": "#strings" }, { "include": "#comments" }, { "name": "keyword.other.import.dart", "match": "b(as|show|hide)b" } ] }, { "include": "#comments" }, { "include": "#punctuation" }, { "include": "#annotations" }, { "include": "#keywords" }, { "include": "#constants-and-special-vars" }, { "include": "#strings" } ], "repository": { "dartdoc": { "patterns": [ { "match": "([.*?])", "captures": { "0": { "name": "variable.name.source.dart" } } }, { "match": "^ {4,}(?![ *]).*", "captures": { "0": { "name": "variable.name.source.dart" } } }, { "contentName": "variable.other.source.dart", "begin": "```.*?$", "end": "```" }, { "match": "(`.*?`)", "captures": { "0": { "name": "variable.other.source.dart" } } }, { "match": "(`.*?`)", "captures": { "0": { "name": "variable.other.source.dart" } } }, { "match": "(* ((    ).*))$", "captures": { "2": { "name": "variable.other.source.dart" } } }, { "match": "(*    .*)$" } ] }, "comments": { "patterns": [ { "name": "comment.block.empty.dart", "match": "/**/", "captures": { "0": { "name": "punctuation.definition.comment.dart" } } }, { "include": "#comments-doc-oldschool" }, { "include": "#comments-doc" }, { "include": "#comments-inline" } ] }, "comments-doc-oldschool": { "patterns": [ { "name": "comment.block.documentation.dart", "begin": "/**", "end": "*/", "patterns": [ { "include": "#comments-doc-oldschool" }, { "include": "#comments-block" }, { "include": "#dartdoc" } ] } ] }, "comments-doc": { "patterns": [ { "name": "comment.block.documentation.dart", "begin": "///", "while": "^s*///", "patterns": [ { "include": "#dartdoc" } ] } ] }, "comments-inline": { "patterns": [ { "include": "#comments-block" }, { "match": "((//).*)$", "captures": { "1": { "name": "comment.line.double-slash.dart" } } } ] }, "comments-block": { "patterns": [ { "name": "comment.block.dart", "begin": "/*", "end": "*/", "patterns": [ { "include": "#comments-block" } ] } ] }, "annotations": { "patterns": [ { "name": "storage.type.annotation.dart", "match": "@[a-zA-Z]+" } ] }, "constants-and-special-vars": { "patterns": [ { "name": "constant.language.dart", "match": "(?<!$)b(true|false|null)b(?!$)" }, { "name": "variable.language.dart", "match": "(?<!$)b(this|super)b(?!$)" }, { "name": "constant.numeric.dart", "match": "(?<!$)b((0(x|X)[0-9a-fA-F]*)|(([0-9]+.?[0-9]*)|(.[0-9]+))((e|E)(+|-)?[0-9]+)?)b(?!$)" }, { "name": "support.class.dart", "match": "(?<![a-zA-Z0-9_$])([_$]*[A-Z][a-zA-Z0-9_$]*|boolb|numb|intb|doubleb|dynamicb)" }, { "match": "([_$]*[a-z][a-zA-Z0-9_$]*)(<|(|s+=>)", "captures": { "1": { "name": "entity.name.function.dart" } } } ] }, "keywords": { "patterns": [ { "name": "keyword.cast.dart", "match": "(?<!$)basb(?!$)" }, { "name": "keyword.control.catch-exception.dart", "match": "(?<!$)b(try|on|catch|finally|throw|rethrow)b(?!$)" }, { "name": "keyword.control.dart", "match": "(?<!$)b(break|case|continue|default|do|else|for|if|in|return|switch|while)b(?!$)" }, { "name": "keyword.control.dart", "match": "(?<!$)b(sync(*)?|async(*)?|await|yield(*)?)b(?!$)" }, { "name": "keyword.control.dart", "match": "(?<!$)bassertb(?!$)" }, { "name": "keyword.control.new.dart", "match": "(?<!$)b(new)b(?!$)" }, { "name": "keyword.declaration.dart", "match": "(?<!$)b(abstract|class|enum|extends|extension|external|factory|implements|get|mixin|native|operator|set|typedef|with|covariant)b(?!$)" }, { "name": "keyword.operator.dart", "match": "(?<!$)b(is!?)b(?!$)" }, { "name": "keyword.operator.ternary.dart", "match": "?|:" }, { "name": "keyword.operator.bitwise.dart", "match": "(<<|>>>?|~|^|||&)" }, { "name": "keyword.operator.assignment.bitwise.dart", "match": "((&|^|||<<|>>>?)=)" }, { "name": "keyword.operator.closure.dart", "match": "(=>)" }, { "name": "keyword.operator.comparison.dart", "match": "(==|!=|<=?|>=?)" }, { "name": "keyword.operator.assignment.arithmetic.dart", "match": "(([+*/%-]|~)=)" }, { "name": "keyword.operator.assignment.dart", "match": "(=)" }, { "name": "keyword.operator.increment-decrement.dart", "match": "(--|++)" }, { "name": "keyword.operator.arithmetic.dart", "match": "(-|+|*|/|~/|%)" }, { "name": "keyword.operator.logical.dart", "match": "(!|&&|||)" }, { "name": "storage.modifier.dart", "match": "(?<!$)b(static|final|const|required|late)b(?!$)" }, { "name": "storage.type.primitive.dart", "match": "(?<!$)b(?:void|var)b(?!$)" } ] }, "string-interp": { "patterns": [ { "match": "$(([a-zA-Z0-9_]+)|{([^{}]+)})", "captures": { "2": { "name": "variable.parameter.dart" }, "3": { "name": "variable.parameter.dart" } } }, { "name": "constant.character.escape.dart", "match": "." } ] }, "strings": { "patterns": [ { "name": "string.interpolated.triple.double.dart", "begin": "(?<!r)"""", "end": """"(?!")", "patterns": [ { "include": "#string-interp" } ] }, { "name": "string.interpolated.triple.single.dart", "begin": "(?<!r)'''", "end": "'''(?!')", "patterns": [ { "include": "#string-interp" } ] }, { "name": "string.quoted.triple.double.dart", "begin": "r"""", "end": """"(?!")" }, { "name": "string.quoted.triple.single.dart", "begin": "r'''", "end": "'''(?!')" }, { "name": "string.interpolated.double.dart", "begin": "(?<!|r)"", "end": """, "patterns": [ { "name": "invalid.string.newline", "match": "n" }, { "include": "#string-interp" } ] }, { "name": "string.quoted.double.dart", "begin": "r"", "end": """, "patterns": [ { "name": "invalid.string.newline", "match": "n" } ] }, { "name": "string.interpolated.single.dart", "begin": "(?<!|r)'", "end": "'", "patterns": [ { "name": "invalid.string.newline", "match": "n" }, { "include": "#string-interp" } ] }, { "name": "string.quoted.single.dart", "begin": "r'", "end": "'", "patterns": [ { "name": "invalid.string.newline", "match": "n" } ] } ] }, "punctuation": { "patterns": [ { "name": "punctuation.comma.dart", "match": "," }, { "name": "punctuation.terminator.dart", "match": ";" }, { "name": "punctuation.dot.dart", "match": "." } ] } } } </ins>  No newline at end of file


graphLine: register('graph-line', 0xebe2), graphScatter: register('graph-scatter', 0xebe3), pieChart: register('pie-chart', 0xebe4), <del> bracket: register('bracket', 0xebe4), </del> bracketDot: register('bracket-dot', 0xebe5), bracketError: register('bracket-error', 0xebe6), lockSmall: register('lock-small', 0xebe7),


const handleTitleClickOrTouch = (e: MouseEvent | GestureEvent): void => { let target: HTMLElement; if (e instanceof MouseEvent) { <del> if (e.button !== 0) { return undefined; // only for left mouse click </del> <ins> if (e.button !== 0 || (isMacintosh && e.ctrlKey)) { return undefined; // only for left mouse click (ctrl+click on macos is right-click) </ins> } target = e.target as HTMLElement;


import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; import { IShellLaunchConfig, TerminalExitReason, TerminalLocation, TerminalSettingId } from 'vs/platform/terminal/common/terminal'; import { IEditorGroup } from 'vs/workbench/services/editor/common/editorGroupsService'; <del> import { ILifecycleService } from 'vs/workbench/services/lifecycle/common/lifecycle'; </del> <ins> import { ILifecycleService, ShutdownReason, WillShutdownEvent } from 'vs/workbench/services/lifecycle/common/lifecycle'; </ins> import { ConfirmOnKill } from 'vs/workbench/contrib/terminal/common/terminal'; import { IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration';


...this.createExtHostOutputChannel(name, channelPromise), trace(value: string, ...args: any[]): void { validate(); <del> channelPromise.then(channel => channel.info(value, ...args)); </del> <ins> channelPromise.then(channel => channel.trace(value, ...args)); </ins> }, debug(value: string, ...args: any[]): void { validate();


"cssnano": "^4.1.11", "debounce": "^1.0.0", "deemon": "^1.8.0", <del> "electron": "19.1.8", </del> <ins> "electron": "19.1.9", </ins> "eslint": "8.7.0", "eslint-plugin-header": "3.1.1", "eslint-plugin-jsdoc": "^39.3.2",


}, 'workbench.editor.enablePreviewFromQuickOpen': { 'type': 'boolean', <del> 'markdownDescription': localize('enablePreviewFromQuickOpen', "Controls whether editors opened from Quick Open show as preview editors. Preview editors do not stay open, and are reused until explicitly set to be kept open (via double click or editing). This value is ignored when `#workbench.editor.enablePreview#` is disabled."), </del> <ins> 'markdownDescription': localize('enablePreviewFromQuickOpen', "Controls whether editors opened from Quick Open show as preview editors. Preview editors do not stay open, and are reused until explicitly set to be kept open (via double click or editing). When enabled, hold Ctrl before selection to open an editor as a non-preview. This value is ignored when `#workbench.editor.enablePreview#` is disabled."), </ins> 'default': false }, 'workbench.editor.enablePreviewFromCodeNavigation': {