@codingame/monaco-vscode-api 13.1.6 → 14.0.0

package/vscode/src/vs/workbench/contrib/notebook/common/notebookRange.js

@@ -0,0 +1,73 @@
+
+
+function isICellRange(candidate) {
+    if (!candidate || typeof candidate !== 'object') {
+        return false;
+    }
+    return typeof candidate.start === 'number'
+        && typeof candidate.end === 'number';
+}
+function cellIndexesToRanges(indexes) {
+    indexes.sort((a, b) => a - b);
+    const first = indexes.shift();
+    if (first === undefined) {
+        return [];
+    }
+    return ( indexes.reduce(function (ranges, num) {
+        if (num <= ranges[0][1]) {
+            ranges[0][1] = num + 1;
+        }
+        else {
+            ranges.unshift([num, num + 1]);
+        }
+        return ranges;
+    }, [[first, first + 1]]).reverse().map(val => ({ start: val[0], end: val[1] })));
+}
+function cellRangesToIndexes(ranges) {
+    const indexes = ranges.reduce((a, b) => {
+        for (let i = b.start; i < b.end; i++) {
+            a.push(i);
+        }
+        return a;
+    }, []);
+    return indexes;
+}
+function reduceCellRanges(ranges) {
+    const sorted = ranges.sort((a, b) => a.start - b.start);
+    const first = sorted[0];
+    if (!first) {
+        return [];
+    }
+    const reduced = sorted.reduce((prev, curr) => {
+        const last = prev[prev.length - 1];
+        if (last.end >= curr.start) {
+            last.end = Math.max(last.end, curr.end);
+        }
+        else {
+            prev.push(curr);
+        }
+        return prev;
+    }, [first]);
+    if (reduced.length > 1) {
+        return reduced.filter(range => !(range.start === range.end && range.start === 0));
+    }
+    return reduced;
+}
+function cellRangesEqual(a, b) {
+    a = reduceCellRanges(a);
+    b = reduceCellRanges(b);
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i].start !== b[i].start || a[i].end !== b[i].end) {
+            return false;
+        }
+    }
+    return true;
+}
+function cellRangeContains(range, other) {
+    return other.start >= range.start && other.end <= range.end;
+}
+
+export { cellIndexesToRanges, cellRangeContains, cellRangesEqual, cellRangesToIndexes, isICellRange, reduceCellRanges };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookService.d.ts

@@ -0,0 +1,36 @@
+import { URI } from "../../../../base/common/uri.js";
+import { NotebookData, TransientOptions, NotebookExtensionDescription } from "./notebookCommon.js";
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { VSBuffer } from "../../../../base/common/buffer.js";
+import { IFileStatWithMetadata, IWriteFileOptions } from "../../../../platform/files/common/files.js";
+import { ITextQuery } from "../../../services/search/common/search.js";
+import { NotebookPriorityInfo } from "@codingame/monaco-vscode-42931eb9-e564-530c-bafc-fa23ab43a070-common/vscode/vs/workbench/contrib/search/common/search";
+import { INotebookFileMatchNoModel } from "../../search/common/searchNotebookHelpers.js";
+export interface INotebookContentProvider {
+    options: TransientOptions;
+    open(uri: URI, backupId: string | VSBuffer | undefined, untitledDocumentData: VSBuffer | undefined, token: CancellationToken): Promise<{
+        data: NotebookData;
+        transientOptions: TransientOptions;
+    }>;
+    backup(uri: URI, token: CancellationToken): Promise<string | VSBuffer>;
+}
+export interface INotebookSerializer {
+    options: TransientOptions;
+    dataToNotebook(data: VSBuffer): Promise<NotebookData>;
+    notebookToData(data: NotebookData): Promise<VSBuffer>;
+    save(uri: URI, versionId: number, options: IWriteFileOptions, token: CancellationToken): Promise<IFileStatWithMetadata>;
+    searchInNotebooks(textQuery: ITextQuery, token: CancellationToken, allPriorityInfo: Map<string, NotebookPriorityInfo[]>): Promise<{
+        results: INotebookFileMatchNoModel<URI>[];
+        limitHit: boolean;
+    }>;
+}
+export interface INotebookRawData {
+    data: NotebookData;
+    transientOptions: TransientOptions;
+}
+export declare class SimpleNotebookProviderInfo {
+    readonly viewType: string;
+    readonly serializer: INotebookSerializer;
+    readonly extensionData: NotebookExtensionDescription;
+    constructor(viewType: string, serializer: INotebookSerializer, extensionData: NotebookExtensionDescription);
+}

package/vscode/src/vs/workbench/contrib/notebook/common/notebookService.js

@@ -0,0 +1,11 @@
+
+
+class SimpleNotebookProviderInfo {
+    constructor(viewType, serializer, extensionData) {
+        this.viewType = viewType;
+        this.serializer = serializer;
+        this.extensionData = extensionData;
+    }
+}
+
+export { SimpleNotebookProviderInfo };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookService.service.d.ts

@@ -4,12 +4,12 @@ import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
 import { ConfigurationTarget } from "../../../../platform/configuration/common/configuration.js";
-import { SnapshotContext } from "@codingame/monaco-vscode-9d05a43d-c330-5ff1-937e-fde4a3852931-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
-import { NotebookCellTextModel } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel";
+import { SnapshotContext } from "@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
+import { NotebookCellTextModel } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel";
 import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
 import { NotebookExtensionDescription, IOutputDto, IOrderedMimeType, INotebookRendererInfo, INotebookStaticPreloadInfo, INotebookContributionData } from "./notebookCommon.js";
 import { NotebookProviderInfo } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/notebookProvider";
-import { INotebookSerializer, SimpleNotebookProviderInfo } from "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/common/notebookService";
+import { INotebookSerializer, SimpleNotebookProviderInfo } from "./notebookService.js";
 export declare const INotebookService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<INotebookService>;
 export interface INotebookService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/workbench/contrib/notebook/common/notebookSynchronizerService.service.d.ts

@@ -1,6 +1,6 @@
 import { IStoredFileWorkingCopy } from "@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy";
 import { IUntitledFileWorkingCopy } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/services/workingCopy/common/untitledFileWorkingCopy";
-import { NotebookFileWorkingCopyModel } from "@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel";
+import { NotebookFileWorkingCopyModel } from "@codingame/monaco-vscode-168b98e5-dc20-5807-b1f9-798f1f92b37f-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel";
 export declare const INotebookSynchronizerService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<INotebookSynchronizerService>;
 export interface INotebookSynchronizerService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/workbench/contrib/scm/browser/quickDiffModel.service.d.ts

@@ -0,0 +1,8 @@
+import { IReference } from "../../../../base/common/lifecycle.js";
+import { URI } from "../../../../base/common/uri.js";
+import { QuickDiffModelOptions, QuickDiffModel } from "@codingame/monaco-vscode-scm-service-override/vscode/vs/workbench/contrib/scm/browser/quickDiffModel";
+export declare const IQuickDiffModelService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IQuickDiffModelService>;
+export interface IQuickDiffModelService {
+    _serviceBrand: undefined;
+    createQuickDiffModelReference(resource: URI, options?: QuickDiffModelOptions): IReference<QuickDiffModel> | undefined;
+}

package/vscode/src/vs/workbench/contrib/scm/browser/{diff.service.js → quickDiffModel.service.js}

@@ -1,6 +1,6 @@
 
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 
-const IDirtyDiffModelService = ( createDecorator('IDirtyDiffModelService'));
+const IQuickDiffModelService = ( createDecorator('IQuickDiffModelService'));
 
-export { IDirtyDiffModelService };
+export { IQuickDiffModelService };

package/vscode/src/vs/workbench/contrib/scm/common/history.d.ts

@@ -54,6 +54,11 @@ export interface ISCMHistoryItem {
     readonly message: string;
     readonly displayId?: string;
     readonly author?: string;
+    readonly authorEmail?: string;
+    readonly authorIcon?: URI | {
+        light: URI;
+        dark: URI;
+    } | ThemeIcon;
     readonly timestamp?: number;
     readonly statistics?: ISCMHistoryItemStatistics;
     readonly references?: ISCMHistoryItemRef[];
@@ -82,5 +87,4 @@ export interface ISCMHistoryItemChange {
     readonly uri: URI;
     readonly originalUri?: URI;
     readonly modifiedUri?: URI;
-    readonly renameUri?: URI;
 }

package/vscode/src/vs/workbench/contrib/scm/common/quickDiff.d.ts

@@ -1,6 +1,15 @@
 import { URI } from "../../../../base/common/uri.js";
 import { LanguageSelector } from "../../../../editor/common/languageSelector.js";
 import { LineRangeMapping } from "../../../../editor/common/diff/rangeMapping.js";
+import { IChange } from "../../../../editor/common/diff/legacyLinesDiffComputer.js";
+import { IColorTheme } from "../../../../platform/theme/common/themeService.js";
+import { Color } from "../../../../base/common/color.js";
+export declare const minimapGutterModifiedBackground: string;
+export declare const minimapGutterAddedBackground: string;
+export declare const minimapGutterDeletedBackground: string;
+export declare const overviewRulerModifiedForeground: string;
+export declare const overviewRulerAddedForeground: string;
+export declare const overviewRulerDeletedForeground: string;
 export interface QuickDiffProvider {
     label: string;
     rootUri: URI | undefined;
@@ -15,8 +24,28 @@ export interface QuickDiff {
     isSCM: boolean;
     visible: boolean;
 }
+export interface QuickDiffChange {
+    readonly label: string;
+    readonly original: URI;
+    readonly modified: URI;
+    readonly change: IChange;
+    readonly change2: LineRangeMapping;
+}
 export interface QuickDiffResult {
+    readonly label: string;
     readonly original: URI;
     readonly modified: URI;
-    readonly changes: readonly LineRangeMapping[];
+    readonly changes: IChange[];
+    readonly changes2: LineRangeMapping[];
+}
+export declare enum ChangeType {
+    Modify = 0,
+    Add = 1,
+    Delete = 2
 }
+export declare function getChangeType(change: IChange): ChangeType;
+export declare function getChangeTypeColor(theme: IColorTheme, changeType: ChangeType): Color | undefined;
+export declare function compareChanges(a: IChange, b: IChange): number;
+export declare function getChangeHeight(change: IChange): number;
+export declare function getModifiedEndLineNumber(change: IChange): number;
+export declare function lineIntersectsChange(lineNumber: number, change: IChange): boolean;

package/vscode/src/vs/workbench/contrib/scm/common/quickDiff.js

@@ -0,0 +1,95 @@
+
+import { localize } from '../../../../nls.js';
+import { registerColor, transparent } from '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorErrorForeground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+
+const editorGutterModifiedBackground = registerColor('editorGutter.modifiedBackground', {
+    dark: '#1B81A8', light: '#2090D3', hcDark: '#1B81A8', hcLight: '#2090D3'
+}, ( localize(8762, "Editor gutter background color for lines that are modified.")));
+const editorGutterAddedBackground = registerColor('editorGutter.addedBackground', {
+    dark: '#487E02', light: '#48985D', hcDark: '#487E02', hcLight: '#48985D'
+}, ( localize(8763, "Editor gutter background color for lines that are added.")));
+const editorGutterDeletedBackground = registerColor('editorGutter.deletedBackground', editorErrorForeground, ( localize(8764, "Editor gutter background color for lines that are deleted.")));
+const minimapGutterModifiedBackground = registerColor('minimapGutter.modifiedBackground', editorGutterModifiedBackground, ( localize(8765, "Minimap gutter background color for lines that are modified.")));
+const minimapGutterAddedBackground = registerColor('minimapGutter.addedBackground', editorGutterAddedBackground, ( localize(8766, "Minimap gutter background color for lines that are added.")));
+const minimapGutterDeletedBackground = registerColor('minimapGutter.deletedBackground', editorGutterDeletedBackground, ( localize(8767, "Minimap gutter background color for lines that are deleted.")));
+const overviewRulerModifiedForeground = registerColor('editorOverviewRuler.modifiedForeground', ( transparent(editorGutterModifiedBackground, 0.6)), ( localize(8768, 'Overview ruler marker color for modified content.')));
+const overviewRulerAddedForeground = registerColor('editorOverviewRuler.addedForeground', ( transparent(editorGutterAddedBackground, 0.6)), ( localize(8769, 'Overview ruler marker color for added content.')));
+const overviewRulerDeletedForeground = registerColor('editorOverviewRuler.deletedForeground', ( transparent(editorGutterDeletedBackground, 0.6)), ( localize(8770, 'Overview ruler marker color for deleted content.')));
+var ChangeType;
+(function (ChangeType) {
+    ChangeType[ChangeType["Modify"] = 0] = "Modify";
+    ChangeType[ChangeType["Add"] = 1] = "Add";
+    ChangeType[ChangeType["Delete"] = 2] = "Delete";
+})(ChangeType || (ChangeType = {}));
+function getChangeType(change) {
+    if (change.originalEndLineNumber === 0) {
+        return ChangeType.Add;
+    }
+    else if (change.modifiedEndLineNumber === 0) {
+        return ChangeType.Delete;
+    }
+    else {
+        return ChangeType.Modify;
+    }
+}
+function getChangeTypeColor(theme, changeType) {
+    switch (changeType) {
+        case ChangeType.Modify: return theme.getColor(editorGutterModifiedBackground);
+        case ChangeType.Add: return theme.getColor(editorGutterAddedBackground);
+        case ChangeType.Delete: return theme.getColor(editorGutterDeletedBackground);
+    }
+}
+function compareChanges(a, b) {
+    let result = a.modifiedStartLineNumber - b.modifiedStartLineNumber;
+    if (result !== 0) {
+        return result;
+    }
+    result = a.modifiedEndLineNumber - b.modifiedEndLineNumber;
+    if (result !== 0) {
+        return result;
+    }
+    result = a.originalStartLineNumber - b.originalStartLineNumber;
+    if (result !== 0) {
+        return result;
+    }
+    return a.originalEndLineNumber - b.originalEndLineNumber;
+}
+function getChangeHeight(change) {
+    const modified = change.modifiedEndLineNumber - change.modifiedStartLineNumber + 1;
+    const original = change.originalEndLineNumber - change.originalStartLineNumber + 1;
+    if (change.originalEndLineNumber === 0) {
+        return modified;
+    }
+    else if (change.modifiedEndLineNumber === 0) {
+        return original;
+    }
+    else {
+        return modified + original;
+    }
+}
+function getModifiedEndLineNumber(change) {
+    if (change.modifiedEndLineNumber === 0) {
+        return change.modifiedStartLineNumber === 0 ? 1 : change.modifiedStartLineNumber;
+    }
+    else {
+        return change.modifiedEndLineNumber;
+    }
+}
+function lineIntersectsChange(lineNumber, change) {
+    if (lineNumber === 1 && change.modifiedStartLineNumber === 0 && change.modifiedEndLineNumber === 0) {
+        return true;
+    }
+    return lineNumber >= change.modifiedStartLineNumber && lineNumber <= (change.modifiedEndLineNumber || change.modifiedStartLineNumber);
+}
+
+export { ChangeType, compareChanges, getChangeHeight, getChangeType, getChangeTypeColor, getModifiedEndLineNumber, lineIntersectsChange, minimapGutterAddedBackground, minimapGutterDeletedBackground, minimapGutterModifiedBackground, overviewRulerAddedForeground, overviewRulerDeletedForeground, overviewRulerModifiedForeground };

package/vscode/src/vs/workbench/contrib/scm/common/quickDiffService.d.ts

@@ -0,0 +1,17 @@
+import { URI } from "../../../../base/common/uri.js";
+import { Disposable, IDisposable } from "../../../../base/common/lifecycle.js";
+import { QuickDiff, QuickDiffProvider } from "./quickDiff.js";
+import { IQuickDiffService } from "./quickDiff.service.js";
+import { IUriIdentityService } from "../../../../platform/uriIdentity/common/uriIdentity.service.js";
+export declare class QuickDiffService extends Disposable implements IQuickDiffService {
+    private readonly uriIdentityService;
+    readonly _serviceBrand: undefined;
+    private quickDiffProviders;
+    private readonly _onDidChangeQuickDiffProviders;
+    readonly onDidChangeQuickDiffProviders: import("../../../../base/common/event.js").Event<void>;
+    constructor(uriIdentityService: IUriIdentityService);
+    addQuickDiffProvider(quickDiff: QuickDiffProvider): IDisposable;
+    private isQuickDiff;
+    getQuickDiffs(uri: URI, language?: string, isSynchronized?: boolean): Promise<QuickDiff[]>;
+}
+export declare function getOriginalResource(quickDiffService: IQuickDiffService, uri: URI, language: string | undefined, isSynchronized: boolean | undefined): Promise<URI | null>;

package/vscode/src/vs/workbench/contrib/scm/common/quickDiffService.js

@@ -0,0 +1,82 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { isEqualOrParent } from '../../../../base/common/resources.js';
+import { score } from '../../../../editor/common/languageSelector.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.service.js';
+
+function createProviderComparer(uri) {
+    return (a, b) => {
+        if (a.rootUri && !b.rootUri) {
+            return -1;
+        }
+        else if (!a.rootUri && b.rootUri) {
+            return 1;
+        }
+        else if (!a.rootUri && !b.rootUri) {
+            return 0;
+        }
+        const aIsParent = isEqualOrParent(uri, a.rootUri);
+        const bIsParent = isEqualOrParent(uri, b.rootUri);
+        if (aIsParent && bIsParent) {
+            return a.rootUri.fsPath.length - b.rootUri.fsPath.length;
+        }
+        else if (aIsParent) {
+            return -1;
+        }
+        else if (bIsParent) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    };
+}
+let QuickDiffService = class QuickDiffService extends Disposable {
+    constructor(uriIdentityService) {
+        super();
+        this.uriIdentityService = uriIdentityService;
+        this.quickDiffProviders = ( new Set());
+        this._onDidChangeQuickDiffProviders = this._register(( new Emitter()));
+        this.onDidChangeQuickDiffProviders = this._onDidChangeQuickDiffProviders.event;
+    }
+    addQuickDiffProvider(quickDiff) {
+        this.quickDiffProviders.add(quickDiff);
+        this._onDidChangeQuickDiffProviders.fire();
+        return {
+            dispose: () => {
+                this.quickDiffProviders.delete(quickDiff);
+                this._onDidChangeQuickDiffProviders.fire();
+            }
+        };
+    }
+    isQuickDiff(diff) {
+        return !!diff.originalResource && (typeof diff.label === 'string') && (typeof diff.isSCM === 'boolean');
+    }
+    async getQuickDiffs(uri, language = '', isSynchronized = false) {
+        const providers = Array.from(this.quickDiffProviders)
+            .filter(provider => !provider.rootUri || this.uriIdentityService.extUri.isEqualOrParent(uri, provider.rootUri))
+            .sort(createProviderComparer(uri));
+        const diffs = await Promise.all(( providers.map(async (provider) => {
+            const scoreValue = provider.selector ? score(provider.selector, uri, language, isSynchronized, undefined, undefined) : 10;
+            const diff = {
+                originalResource: scoreValue > 0 ? (await provider.getOriginalResource(uri)) ?? undefined : undefined,
+                label: provider.label,
+                isSCM: provider.isSCM,
+                visible: provider.visible
+            };
+            return diff;
+        })));
+        return diffs.filter(this.isQuickDiff);
+    }
+};
+QuickDiffService = ( __decorate([
+    ( __param(0, IUriIdentityService))
+], QuickDiffService));
+async function getOriginalResource(quickDiffService, uri, language, isSynchronized) {
+    const quickDiffs = await quickDiffService.getQuickDiffs(uri, language, isSynchronized);
+    return quickDiffs.length > 0 ? quickDiffs[0].originalResource : null;
+}
+
+export { QuickDiffService, getOriginalResource };

package/vscode/src/vs/workbench/contrib/scm/common/scm.service.d.ts

@@ -1,7 +1,7 @@
 import { Event } from "../../../../base/common/event.js";
+import { IObservable } from "../../../../base/common/observable.js";
 import { URI } from "../../../../base/common/uri.js";
 import { ISCMRepository, ISCMProvider, type ISCMMenus, type ISCMRepositorySortKey, type ISCMViewVisibleRepositoryChangeEvent } from "@codingame/monaco-vscode-ff9fa663-eae3-5274-8573-c2b918871e4b-common/vscode/vs/workbench/contrib/scm/common/scm";
-import { IObservable } from "../../../../base/common/observableInternal/index.js";
 export declare const ISCMService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ISCMService>;
 export interface ISCMService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/workbench/contrib/snippets/browser/snippetCompletionProvider.js

@@ -27,7 +27,7 @@ class SnippetCompletion {
     constructor(snippet, range) {
         this.snippet = snippet;
         this.label = { label: snippet.prefix, description: snippet.name };
-        this.detail = ( localize(8900, "{0} ({1})", snippet.description || snippet.name, snippet.source));
+        this.detail = ( localize(9090, "{0} ({1})", snippet.description || snippet.name, snippet.source));
         this.insertText = snippet.codeSnippet;
         this.extensionId = snippet.extensionId;
         this.range = range;
@@ -121,14 +121,14 @@ let SnippetCompletionProvider = class SnippetCompletionProvider {
             let to = i + 1;
             for (; to < suggestions.length && item.label === suggestions[to].label; to++) {
                 suggestions[to].label.label = ( localize(
-                    8901,
+                    9091,
                     "{0}, {1}",
                     suggestions[to].label.label,
                     suggestions[to].snippet.name
                 ));
             }
             if (to > i + 1) {
-                suggestions[i].label.label = ( localize(8901, "{0}, {1}", suggestions[i].label.label, suggestions[i].snippet.name));
+                suggestions[i].label.label = ( localize(9091, "{0}, {1}", suggestions[i].label.label, suggestions[i].snippet.name));
                 i = to;
             }
         }

package/vscode/src/vs/workbench/contrib/snippets/browser/snippetsFile.js

@@ -207,14 +207,14 @@ class SnippetFile {
             source = this._extension.displayName || this._extension.name;
         }
         else if (this.source === SnippetSource.Workspace) {
-            source = ( localize(8917, "Workspace Snippet"));
+            source = ( localize(9107, "Workspace Snippet"));
         }
         else {
             if (this.isGlobalSnippets) {
-                source = ( localize(8918, "Global User Snippet"));
+                source = ( localize(9108, "Global User Snippet"));
             }
             else {
-                source = ( localize(8919, "User Snippet"));
+                source = ( localize(9109, "User Snippet"));
             }
         }
         for (const _prefix of Iterable.wrap(prefix)) {

package/vscode/src/vs/workbench/contrib/snippets/browser/snippetsService.js

@@ -34,7 +34,7 @@ var snippetExt;
     function toValidSnippet(extension, snippet, languageService) {
         if (isFalsyOrWhitespace(snippet.path)) {
             extension.collector.error(( localize(
-                8920,
+                9110,
                 "Expected string in `contributes.{0}.path`. Provided value: {1}",
                 extension.description.name,
                 String(snippet.path)
@@ -43,7 +43,7 @@ var snippetExt;
         }
         if (isFalsyOrWhitespace(snippet.language) && !snippet.path.endsWith('.code-snippets')) {
             extension.collector.error(( localize(
-                8921,
+                9111,
                 "When omitting the language, the value of `contributes.{0}.path` must be a `.code-snippets`-file. Provided value: {1}",
                 extension.description.name,
                 String(snippet.path)
@@ -52,7 +52,7 @@ var snippetExt;
         }
         if (!isFalsyOrWhitespace(snippet.language) && !languageService.isRegisteredLanguageId(snippet.language)) {
             extension.collector.error(( localize(
-                8922,
+                9112,
                 "Unknown language in `contributes.{0}.language`. Provided value: {1}",
                 extension.description.name,
                 String(snippet.language)
@@ -63,7 +63,7 @@ var snippetExt;
         const snippetLocation = joinPath(extensionLocation, snippet.path);
         if (!isEqualOrParent(snippetLocation, extensionLocation)) {
             extension.collector.error(( localize(
-                8923,
+                9113,
                 "Expected `contributes.{0}.path` ({1}) to be included inside extension's folder ({2}). This might make the extension non-portable.",
                 extension.description.name,
                 snippetLocation.path,
@@ -78,7 +78,7 @@ var snippetExt;
     }
     snippetExt.toValidSnippet = toValidSnippet;
     snippetExt.snippetsContribution = {
-        description: ( localize(8924, 'Contributes snippets.')),
+        description: ( localize(9114, 'Contributes snippets.')),
         type: 'array',
         defaultSnippets: [{ body: [{ language: '', path: '' }] }],
         items: {
@@ -86,12 +86,12 @@ var snippetExt;
             defaultSnippets: [{ body: { language: '${1:id}', path: './snippets/${2:id}.json.' } }],
             properties: {
                 language: {
-                    description: ( localize(8925, 'Language identifier for which this snippet is contributed to.')),
+                    description: ( localize(9115, 'Language identifier for which this snippet is contributed to.')),
                     type: 'string'
                 },
                 path: {
                     description: ( localize(
-                        8926,
+                        9116,
                         'Path of the snippets file. The path is relative to the extension folder and typically starts with \'./snippets/\'.'
                     )),
                     type: 'string'
@@ -336,14 +336,14 @@ let SnippetsService = class SnippetsService {
                             file.load().then(file => {
                                 if (( file.data.some(snippet => snippet.isBogous))) {
                                     extension.collector.warn(( localize(
-                                        8927,
+                                        9117,
                                         "One or more snippets from the extension '{0}' very likely confuse snippet-variables and snippet-placeholders (see https://code.visualstudio.com/docs/editor/userdefinedsnippets#_snippet-syntax for more details)",
                                         extension.description.name
                                     )));
                                 }
                             }, err => {
                                 extension.collector.warn(( localize(
-                                    8928,
+                                    9118,
                                     "The snippet file \"{0}\" could not be read.",
                                     (file.location.toString())
                                 )));

package/vscode/src/vs/workbench/contrib/speech/common/speechService.d.ts

@@ -63,7 +63,8 @@ export interface ISpeechProvider {
 export declare enum AccessibilityVoiceSettingId {
     SpeechTimeout = "accessibility.voice.speechTimeout",
     AutoSynthesize = "accessibility.voice.autoSynthesize",
-    SpeechLanguage = "accessibility.voice.speechLanguage"
+    SpeechLanguage = "accessibility.voice.speechLanguage",
+    IgnoreCodeBlocks = "accessibility.voice.ignoreCodeBlocks"
 }
 export declare const SPEECH_LANGUAGE_CONFIG = AccessibilityVoiceSettingId.SpeechLanguage;
 export declare const SPEECH_LANGUAGES: {