@codingame/monaco-vscode-api 15.0.2 → 16.0.0

package/vscode/src/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service.d.ts

@@ -15,6 +15,7 @@ export interface IFilesConfigurationService {
     hasShortAutoSaveDelay(resourceOrEditor: EditorInput | URI | undefined): boolean;
     getAutoSaveMode(resourceOrEditor: EditorInput | URI | undefined, saveReason?: SaveReason): IAutoSaveMode;
     toggleAutoSave(): Promise<void>;
+    enableAutoSaveAfterShortDelay(resourceOrEditor: EditorInput | URI): IDisposable;
     disableAutoSave(resourceOrEditor: EditorInput | URI): IDisposable;
     readonly onDidChangeReadonly: Event<void>;
     isReadonly(resource: URI, stat?: IBaseFileStat): boolean | IMarkdownString;

package/vscode/src/vs/workbench/services/language/common/languageService.js

@@ -23,25 +23,25 @@ import { isString } from '../../../../base/common/types.js';
 const languagesExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'languages',
     jsonSchema: {
-        description: ( localize(11987, 'Contributes language declarations.')),
+        description: ( localize(12320, 'Contributes language declarations.')),
         type: 'array',
         items: {
             type: 'object',
             defaultSnippets: [{ body: { id: '${1:languageId}', aliases: ['${2:label}'], extensions: ['${3:extension}'], configuration: './language-configuration.json' } }],
             properties: {
                 id: {
-                    description: ( localize(11988, 'ID of the language.')),
+                    description: ( localize(12321, 'ID of the language.')),
                     type: 'string'
                 },
                 aliases: {
-                    description: ( localize(11989, 'Name aliases for the language.')),
+                    description: ( localize(12322, 'Name aliases for the language.')),
                     type: 'array',
                     items: {
                         type: 'string'
                     }
                 },
                 extensions: {
-                    description: ( localize(11990, 'File extensions associated to the language.')),
+                    description: ( localize(12323, 'File extensions associated to the language.')),
                     default: ['.foo'],
                     type: 'array',
                     items: {
@@ -49,21 +49,21 @@ const languagesExtPoint = ExtensionsRegistry.registerExtensionPoint({
                     }
                 },
                 filenames: {
-                    description: ( localize(11991, 'File names associated to the language.')),
+                    description: ( localize(12324, 'File names associated to the language.')),
                     type: 'array',
                     items: {
                         type: 'string'
                     }
                 },
                 filenamePatterns: {
-                    description: ( localize(11992, 'File name glob patterns associated to the language.')),
+                    description: ( localize(12325, 'File name glob patterns associated to the language.')),
                     type: 'array',
                     items: {
                         type: 'string'
                     }
                 },
                 mimetypes: {
-                    description: ( localize(11993, 'Mime types associated to the language.')),
+                    description: ( localize(12326, 'Mime types associated to the language.')),
                     type: 'array',
                     items: {
                         type: 'string'
@@ -71,14 +71,14 @@ const languagesExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 firstLine: {
                     description: ( localize(
-                        11994,
+                        12327,
                         'A regular expression matching the first line of a file of the language.'
                     )),
                     type: 'string'
                 },
                 configuration: {
                     description: ( localize(
-                        11995,
+                        12328,
                         'A relative path to a file containing configuration options for the language.'
                     )),
                     type: 'string',
@@ -87,16 +87,16 @@ const languagesExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 icon: {
                     type: 'object',
                     description: ( localize(
-                        11996,
+                        12329,
                         'A icon to use as file icon, if no icon theme provides one for the language.'
                     )),
                     properties: {
                         light: {
-                            description: ( localize(11997, 'Icon path when a light theme is used')),
+                            description: ( localize(12330, 'Icon path when a light theme is used')),
                             type: 'string'
                         },
                         dark: {
-                            description: ( localize(11998, 'Icon path when a dark theme is used')),
+                            description: ( localize(12331, 'Icon path when a dark theme is used')),
                             type: 'string'
                         }
                     }
@@ -170,11 +170,11 @@ class LanguageTableRenderer extends Disposable {
             return { data: { headers: [], rows: [] }, dispose: () => { } };
         }
         const headers = [
-            ( localize(11999, "ID")),
-            ( localize(12000, "Name")),
-            ( localize(12001, "File Extensions")),
-            ( localize(12002, "Grammar")),
-            ( localize(12003, "Snippets"))
+            ( localize(12332, "ID")),
+            ( localize(12333, "Name")),
+            ( localize(12334, "File Extensions")),
+            ( localize(12335, "Grammar")),
+            ( localize(12336, "Snippets"))
         ];
         const rows = ( languages.sort((a, b) => a.id.localeCompare(b.id))
             .map(l => {
@@ -196,7 +196,7 @@ class LanguageTableRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: 'languages',
-    label: ( localize(12004, "Programming Languages")),
+    label: ( localize(12337, "Programming Languages")),
     access: {
         canToggle: false
     },
@@ -214,7 +214,7 @@ let WorkbenchLanguageService = class WorkbenchLanguageService extends LanguageSe
                 const extension = extensions[i];
                 if (!Array.isArray(extension.value)) {
                     extension.collector.error(( localize(
-                        12005,
+                        12338,
                         "Invalid `contributes.{0}`. Expected an array.",
                         languagesExtPoint.name
                     )));
@@ -294,16 +294,16 @@ function isUndefinedOrStringArray(value) {
 }
 function isValidLanguageExtensionPoint(value, collector) {
     if (!value) {
-        collector?.error(( localize(12006, "Empty value for `contributes.{0}`", languagesExtPoint.name)));
+        collector?.error(( localize(12339, "Empty value for `contributes.{0}`", languagesExtPoint.name)));
         return false;
     }
     if (typeof value.id !== 'string') {
-        collector?.error(( localize(12007, "property `{0}` is mandatory and must be of type `string`", 'id')));
+        collector?.error(( localize(12340, "property `{0}` is mandatory and must be of type `string`", 'id')));
         return false;
     }
     if (!isUndefinedOrStringArray(value.extensions)) {
         collector?.error(( localize(
-            12008,
+            12341,
             "property `{0}` can be omitted and must be of type `string[]`",
             'extensions'
         )));
@@ -311,7 +311,7 @@ function isValidLanguageExtensionPoint(value, collector) {
     }
     if (!isUndefinedOrStringArray(value.filenames)) {
         collector?.error(( localize(
-            12009,
+            12342,
             "property `{0}` can be omitted and must be of type `string[]`",
             'filenames'
         )));
@@ -319,7 +319,7 @@ function isValidLanguageExtensionPoint(value, collector) {
     }
     if (typeof value.firstLine !== 'undefined' && typeof value.firstLine !== 'string') {
         collector?.error(( localize(
-            12010,
+            12343,
             "property `{0}` can be omitted and must be of type `string`",
             'firstLine'
         )));
@@ -327,7 +327,7 @@ function isValidLanguageExtensionPoint(value, collector) {
     }
     if (typeof value.configuration !== 'undefined' && typeof value.configuration !== 'string') {
         collector?.error(( localize(
-            12011,
+            12344,
             "property `{0}` can be omitted and must be of type `string`",
             'configuration'
         )));
@@ -335,7 +335,7 @@ function isValidLanguageExtensionPoint(value, collector) {
     }
     if (!isUndefinedOrStringArray(value.aliases)) {
         collector?.error(( localize(
-            12012,
+            12345,
             "property `{0}` can be omitted and must be of type `string[]`",
             'aliases'
         )));
@@ -343,7 +343,7 @@ function isValidLanguageExtensionPoint(value, collector) {
     }
     if (!isUndefinedOrStringArray(value.mimetypes)) {
         collector?.error(( localize(
-            12013,
+            12346,
             "property `{0}` can be omitted and must be of type `string[]`",
             'mimetypes'
         )));
@@ -352,7 +352,7 @@ function isValidLanguageExtensionPoint(value, collector) {
     if (typeof value.icon !== 'undefined') {
         if (typeof value.icon !== 'object' || typeof value.icon.light !== 'string' || typeof value.icon.dark !== 'string') {
             collector?.error(( localize(
-                12014,
+                12347,
                 "property `{0}` can be omitted and must be of type `object` with properties `{1}` and `{2}` of type `string`",
                 'icon',
                 'light',

package/vscode/src/vs/workbench/services/layout/browser/layoutService.service.d.ts

@@ -5,7 +5,7 @@ import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { ILayoutService } from "../../../../platform/layout/browser/layoutService.service.js";
 import { Part } from "@codingame/monaco-vscode-d8236b3b-b91a-522d-89f4-94d70a546f6a-common/vscode/vs/workbench/browser/part";
-import { PanelAlignment, Parts, SINGLE_WINDOW_PARTS, MULTI_WINDOW_PARTS, Position } from "@codingame/monaco-vscode-81f603ca-d6ea-5402-90dd-3014dffc63b4-common/vscode/vs/workbench/services/layout/browser/layoutService";
+import { PanelAlignment, Parts, SINGLE_WINDOW_PARTS, MULTI_WINDOW_PARTS, Position } from "@codingame/monaco-vscode-b1110435-a331-5549-ab1e-aa3d763c3a1f-common/vscode/vs/workbench/services/layout/browser/layoutService";
 export declare const IWorkbenchLayoutService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWorkbenchLayoutService>;
 export interface IWorkbenchLayoutService extends ILayoutService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/workbench/services/lifecycle/common/lifecycle.service.d.ts

@@ -9,6 +9,7 @@ export interface ILifecycleService {
     readonly onShutdownVeto: Event<void>;
     readonly onBeforeShutdownError: Event<BeforeShutdownErrorEvent>;
     readonly onWillShutdown: Event<WillShutdownEvent>;
+    readonly willShutdown: boolean;
     readonly onDidShutdown: Event<void>;
     when(phase: LifecyclePhase): Promise<void>;
     shutdown(): Promise<void>;

package/vscode/src/vs/workbench/services/lifecycle/common/lifecycleService.d.ts

@@ -23,6 +23,8 @@ export declare abstract class AbstractLifecycleService extends Disposable implem
     get startupKind(): StartupKind;
     private _phase;
     get phase(): LifecyclePhase;
+    protected _willShutdown: boolean;
+    get willShutdown(): boolean;
     private readonly phaseWhen;
     protected shutdownReason: ShutdownReason | undefined;
     constructor(logService: ILogService, storageService: IStorageService);

package/vscode/src/vs/workbench/services/lifecycle/common/lifecycleService.js

@@ -15,6 +15,7 @@ let AbstractLifecycleService = class AbstractLifecycleService extends Disposable
     static { this.LAST_SHUTDOWN_REASON_KEY = 'lifecyle.lastShutdownReason'; }
     get startupKind() { return this._startupKind; }
     get phase() { return this._phase; }
+    get willShutdown() { return this._willShutdown; }
     constructor(logService, storageService) {
         super();
         this.logService = logService;
@@ -30,6 +31,7 @@ let AbstractLifecycleService = class AbstractLifecycleService extends Disposable
         this._onShutdownVeto = this._register(( new Emitter()));
         this.onShutdownVeto = this._onShutdownVeto.event;
         this._phase = LifecyclePhase.Starting;
+        this._willShutdown = false;
         this.phaseWhen = ( new Map());
         this._startupKind = this.resolveStartupKind();
         this._register(this.storageService.onWillSaveState(e => {

package/vscode/src/vs/workbench/services/log/common/logConstants.js

@@ -2,7 +2,7 @@
 import { localize } from '../../../../nls.js';
 
 const windowLogId = 'rendererLog';
-const windowLogGroup = { id: windowLogId, name: ( localize(12021, "Window")) };
+const windowLogGroup = { id: windowLogId, name: ( localize(12354, "Window")) };
 const showWindowLogActionId = 'workbench.action.showWindowLog';
 
 export { showWindowLogActionId, windowLogGroup, windowLogId };

package/vscode/src/vs/workbench/services/notebook/common/notebookDocumentService.d.ts

@@ -11,6 +11,14 @@ export declare function parse(cell: URI): {
 export declare function generate(notebook: URI, handle: number): URI;
 export declare function parseMetadataUri(metadata: URI): URI | undefined;
 export declare function generateMetadataUri(notebook: URI): URI;
+export declare function extractCellOutputDetails(uri: URI): {
+    notebook: URI;
+    openIn: string;
+    outputId?: string;
+    cellFragment?: string;
+    outputIndex?: number;
+    cellHandle?: number;
+} | undefined;
 export declare class NotebookDocumentWorkbenchService implements INotebookDocumentService {
     readonly _serviceBrand: undefined;
     private readonly _documents;

package/vscode/src/vs/workbench/services/notebook/common/notebookDocumentService.js

@@ -43,6 +43,30 @@ function generateMetadataUri(notebook) {
     const fragment = `${encodeBase64(VSBuffer.fromString(notebook.scheme), true, true)}`;
     return notebook.with({ scheme: Schemas.vscodeNotebookMetadata, fragment });
 }
+function extractCellOutputDetails(uri) {
+    if (uri.scheme !== Schemas.vscodeNotebookCellOutput) {
+        return;
+    }
+    const params = ( new URLSearchParams(uri.query));
+    const openIn = params.get('openIn');
+    if (!openIn) {
+        return;
+    }
+    const outputId = params.get('outputId') ?? undefined;
+    const parsedCell = parse(uri.with({ scheme: Schemas.vscodeNotebookCell, query: null }));
+    const outputIndex = params.get('outputIndex') ? parseInt(params.get('outputIndex') || '', 10) : undefined;
+    if (parsedCell?.notebook === undefined || parsedCell?.handle === undefined) {
+        throw ( new Error('Invalid cell URI'));
+    }
+    return {
+        notebook: parsedCell.notebook,
+        openIn: openIn,
+        outputId: outputId,
+        outputIndex: outputIndex,
+        cellHandle: parsedCell.handle,
+        cellFragment: uri.fragment,
+    };
+}
 class NotebookDocumentWorkbenchService {
     constructor() {
         this._documents = ( new ResourceMap());
@@ -57,6 +81,15 @@ class NotebookDocumentWorkbenchService {
                 }
             }
         }
+        if (uri.scheme === Schemas.vscodeNotebookCellOutput) {
+            const parsedData = extractCellOutputDetails(uri);
+            if (parsedData) {
+                const document = this._documents.get(parsedData.notebook);
+                if (document) {
+                    return document;
+                }
+            }
+        }
         return this._documents.get(uri);
     }
     addNotebookDocument(document) {
@@ -67,4 +100,4 @@ class NotebookDocumentWorkbenchService {
     }
 }
 
-export { NotebookDocumentWorkbenchService, generate, generateMetadataUri, parse, parseMetadataUri };
+export { NotebookDocumentWorkbenchService, extractCellOutputDetails, generate, generateMetadataUri, parse, parseMetadataUri };

package/vscode/src/vs/workbench/services/preferences/common/preferences.service.d.ts

@@ -3,7 +3,7 @@ import { URI } from "../../../../base/common/uri.js";
 import { ConfigurationTarget } from "../../../../platform/configuration/common/configuration.js";
 import { IEditorPane } from "../../../common/editor.js";
 import { EditorInput } from "../../../common/editor/editorInput.js";
-import { IPreferencesEditorModel, ISetting, IOpenSettingsOptions, IOpenKeybindingsEditorOptions } from "@codingame/monaco-vscode-52bb4d5b-ba1a-57fd-9bee-b28824214eac-common/vscode/vs/workbench/services/preferences/common/preferences";
+import { IPreferencesEditorModel, ISetting, IOpenSettingsOptions, IOpenKeybindingsEditorOptions } from "@codingame/monaco-vscode-2b1a9082-790f-527f-b013-d1b29d6265a3-common/vscode/vs/workbench/services/preferences/common/preferences";
 import { Settings2EditorModel } from "@codingame/monaco-vscode-preferences-service-override/vscode/vs/workbench/services/preferences/common/preferencesModels";
 export declare const IPreferencesService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IPreferencesService>;
 export interface IPreferencesService {

package/vscode/src/vs/workbench/services/remote/common/remoteExplorerService.js

@@ -38,7 +38,7 @@ const getStartedWalkthrough = {
     required: ['id'],
     properties: {
         id: {
-            description: ( localize(12077, 'The ID of a Get Started walkthrough to open.')),
+            description: ( localize(12410, 'The ID of a Get Started walkthrough to open.')),
             type: 'string'
         },
     }
@@ -46,12 +46,12 @@ const getStartedWalkthrough = {
 const remoteHelpExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'remoteHelp',
     jsonSchema: {
-        description: ( localize(12078, 'Contributes help information for Remote')),
+        description: ( localize(12411, 'Contributes help information for Remote')),
         type: 'object',
         properties: {
             'getStarted': {
                 description: ( localize(
-                    12079,
+                    12412,
                     "The url, or a command that returns the url, to your project's Getting Started page, or a walkthrough ID contributed by your project's extension"
                 )),
                 oneOf: [
@@ -61,29 +61,29 @@ const remoteHelpExtPoint = ExtensionsRegistry.registerExtensionPoint({
             },
             'documentation': {
                 description: ( localize(
-                    12080,
+                    12413,
                     "The url, or a command that returns the url, to your project's documentation page"
                 )),
                 type: 'string'
             },
             'feedback': {
                 description: ( localize(
-                    12081,
+                    12414,
                     "The url, or a command that returns the url, to your project's feedback reporter"
                 )),
                 type: 'string',
-                markdownDeprecationMessage: ( localize(12082, "Use {0} instead", '`reportIssue`'))
+                markdownDeprecationMessage: ( localize(12415, "Use {0} instead", '`reportIssue`'))
             },
             'reportIssue': {
                 description: ( localize(
-                    12083,
+                    12416,
                     "The url, or a command that returns the url, to your project's issue reporter"
                 )),
                 type: 'string'
             },
             'issues': {
                 description: ( localize(
-                    12084,
+                    12417,
                     "The url, or a command that returns the url, to your project's issues list"
                 )),
                 type: 'string'

package/vscode/src/vs/workbench/services/remote/common/tunnelModel.js

@@ -28,8 +28,8 @@ const TUNNELS_TO_RESTORE = 'remote.tunnels.toRestore';
 const TUNNELS_TO_RESTORE_EXPIRATION = 'remote.tunnels.toRestoreExpiration';
 const RESTORE_EXPIRATION_TIME = 1000 * 60 * 60 * 24 * 14;
 const ACTIVATION_EVENT = 'onTunnel';
-const forwardedPortsFeaturesEnabled = ( new RawContextKey('forwardedPortsViewEnabled', false, ( localize(12085, "Whether the Ports view is enabled."))));
-const forwardedPortsViewEnabled = ( new RawContextKey('forwardedPortsViewOnlyEnabled', false, ( localize(12085, "Whether the Ports view is enabled."))));
+const forwardedPortsFeaturesEnabled = ( new RawContextKey('forwardedPortsViewEnabled', false, ( localize(12418, "Whether the Ports view is enabled."))));
+const forwardedPortsViewEnabled = ( new RawContextKey('forwardedPortsViewOnlyEnabled', false, ( localize(12418, "Whether the Ports view is enabled."))));
 function parseAddress(address) {
     const matches = address.match(/^([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*:)?([0-9]+)$/);
     if (!matches) {
@@ -51,11 +51,11 @@ var TunnelSource;
 })(TunnelSource || (TunnelSource = {}));
 const UserTunnelSource = {
     source: TunnelSource.User,
-    description: ( localize(12086, "User Forwarded"))
+    description: ( localize(12419, "User Forwarded"))
 };
 const AutoTunnelSource = {
     source: TunnelSource.Auto,
-    description: ( localize(12087, "Auto Forwarded"))
+    description: ( localize(12420, "Auto Forwarded"))
 };
 function mapHasAddress(map, host, port) {
     const initialAddress = map.get(makeAddress(host, port));
@@ -569,7 +569,7 @@ let TunnelModel = class TunnelModel extends Disposable {
         }
         this.mismatchCooldown = newCooldown;
         const mismatchString = ( localize(
-            12088,
+            12421,
             "Local port {0} could not be used for forwarding to remote port {1}.\n\nThis usually happens when there is already another process using local port {0}.\n\nPort number {2} has been used instead.",
             expectedLocal,
             tunnel.tunnelRemotePort,
@@ -736,7 +736,7 @@ let TunnelModel = class TunnelModel extends Disposable {
                     privacy: TunnelPrivacyId.ConstantPrivate,
                     source: {
                         source: TunnelSource.Extension,
-                        description: ( localize(12089, "Statically Forwarded"))
+                        description: ( localize(12422, "Statically Forwarded"))
                     }
                 });
                 this.tunnelService.setEnvironmentTunnel(tunnel.remoteAddress.host, tunnel.remoteAddress.port, localAddress, TunnelPrivacyId.ConstantPrivate, TunnelProtocol.Http);

package/vscode/src/vs/workbench/services/search/common/queryBuilder.js

@@ -354,7 +354,7 @@ let QueryBuilder = class QueryBuilder {
             else {
                 const probableWorkspaceFolderNameMatch = searchPath.match(/\.[\/\\](.+)[\/\\]?/);
                 const probableWorkspaceFolderName = probableWorkspaceFolderNameMatch ? probableWorkspaceFolderNameMatch[1] : searchPath;
-                const searchPathNotFoundError = ( localize(12093, "Workspace folder does not exist: {0}", probableWorkspaceFolderName));
+                const searchPathNotFoundError = ( localize(12426, "Workspace folder does not exist: {0}", probableWorkspaceFolderName));
                 throw ( new Error(searchPathNotFoundError));
             }
         }

package/vscode/src/vs/workbench/services/statusbar/browser/statusbar.d.ts

@@ -2,7 +2,7 @@ import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { ThemeColor } from "../../../../base/common/themables.js";
 import { Command } from "../../../../editor/common/languages.js";
 import { IMarkdownString } from "../../../../base/common/htmlContent.js";
-import { IManagedHoverContentOrFactory } from "@codingame/monaco-vscode-view-status-bar-service-override/vscode/vs/base/browser/ui/hover/hover";
+import { IManagedHoverTooltipHTMLElement, IManagedHoverTooltipMarkdownString } from "../../../../base/browser/ui/hover/hover.js";
 import { ColorIdentifier } from "../../../../platform/theme/common/colorRegistry.js";
 export declare enum StatusbarAlignment {
     LEFT = 0,
@@ -31,7 +31,7 @@ export interface IStatusbarStyleOverride {
 }
 export type StatusbarEntryKind = "standard" | "warning" | "error" | "prominent" | "remote" | "offline";
 export declare const StatusbarEntryKinds: StatusbarEntryKind[];
-export type TooltipContent = IMarkdownString | IManagedHoverContentOrFactory;
+export type TooltipContent = string | IMarkdownString | HTMLElement | IManagedHoverTooltipMarkdownString | IManagedHoverTooltipHTMLElement;
 export interface ITooltipWithCommands {
     readonly content: TooltipContent;
     readonly commands: Command[];

package/vscode/src/vs/workbench/services/themes/common/colorExtensionPoint.js

@@ -28,30 +28,30 @@ const colorIdPattern = '^\\w+[.\\w+]*$';
 const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'colors',
     jsonSchema: {
-        description: ( localize(12158, 'Contributes extension defined themable colors')),
+        description: ( localize(12493, 'Contributes extension defined themable colors')),
         type: 'array',
         items: {
             type: 'object',
             properties: {
                 id: {
                     type: 'string',
-                    description: ( localize(12159, 'The identifier of the themable color')),
+                    description: ( localize(12494, 'The identifier of the themable color')),
                     pattern: colorIdPattern,
                     patternErrorMessage: ( localize(
-                        12160,
+                        12495,
                         'Identifiers must only contain letters, digits and dots and can not start with a dot'
                     )),
                 },
                 description: {
                     type: 'string',
-                    description: ( localize(12161, 'The description of the themable color')),
+                    description: ( localize(12496, 'The description of the themable color')),
                 },
                 defaults: {
                     type: 'object',
                     properties: {
                         light: {
                             description: ( localize(
-                                12162,
+                                12497,
                                 'The default color for light themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default.'
                             )),
                             type: 'string',
@@ -62,7 +62,7 @@ const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                         },
                         dark: {
                             description: ( localize(
-                                12163,
+                                12498,
                                 'The default color for dark themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default.'
                             )),
                             type: 'string',
@@ -73,7 +73,7 @@ const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                         },
                         highContrast: {
                             description: ( localize(
-                                12164,
+                                12499,
                                 'The default color for high contrast dark themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default. If not provided, the `dark` color is used as default for high contrast dark themes.'
                             )),
                             type: 'string',
@@ -84,7 +84,7 @@ const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                         },
                         highContrastLight: {
                             description: ( localize(
-                                12165,
+                                12500,
                                 'The default color for high contrast light themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default. If not provided, the `light` color is used as default for high contrast light themes.'
                             )),
                             type: 'string',
@@ -107,7 +107,7 @@ class ColorExtensionPoint {
                 const extensionValue = extension.value;
                 const collector = extension.collector;
                 if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(( localize(12166, "'configuration.colors' must be a array")));
+                    collector.error(( localize(12501, "'configuration.colors' must be a array")));
                     return;
                 }
                 const parseColorValue = (s, name) => {
@@ -120,7 +120,7 @@ class ColorExtensionPoint {
                         }
                     }
                     collector.error(( localize(
-                        12167,
+                        12502,
                         "{0} must be either a color value in hex (#RRGGBB[AA] or #RGB[A]) or the identifier of a themable color which provides the default.",
                         name
                     )));
@@ -128,19 +128,19 @@ class ColorExtensionPoint {
                 };
                 for (const colorContribution of extensionValue) {
                     if (typeof colorContribution.id !== 'string' || colorContribution.id.length === 0) {
-                        collector.error(( localize(12168, "'configuration.colors.id' must be defined and can not be empty")));
+                        collector.error(( localize(12503, "'configuration.colors.id' must be defined and can not be empty")));
                         return;
                     }
                     if (!colorContribution.id.match(colorIdPattern)) {
                         collector.error(( localize(
-                            12169,
+                            12504,
                             "'configuration.colors.id' must only contain letters, digits and dots and can not start with a dot"
                         )));
                         return;
                     }
                     if (typeof colorContribution.description !== 'string' || colorContribution.id.length === 0) {
                         collector.error(( localize(
-                            12170,
+                            12505,
                             "'configuration.colors.description' must be defined and can not be empty"
                         )));
                         return;
@@ -148,21 +148,21 @@ class ColorExtensionPoint {
                     const defaults = colorContribution.defaults;
                     if (!defaults || typeof defaults !== 'object' || typeof defaults.light !== 'string' || typeof defaults.dark !== 'string') {
                         collector.error(( localize(
-                            12171,
+                            12506,
                             "'configuration.colors.defaults' must be defined and must contain 'light' and 'dark'"
                         )));
                         return;
                     }
                     if (defaults.highContrast && typeof defaults.highContrast !== 'string') {
                         collector.error(( localize(
-                            12172,
+                            12507,
                             "If defined, 'configuration.colors.defaults.highContrast' must be a string."
                         )));
                         return;
                     }
                     if (defaults.highContrastLight && typeof defaults.highContrastLight !== 'string') {
                         collector.error(( localize(
-                            12173,
+                            12508,
                             "If defined, 'configuration.colors.defaults.highContrastLight' must be a string."
                         )));
                         return;
@@ -198,11 +198,11 @@ class ColorDataRenderer extends Disposable {
             return { data: { headers: [], rows: [] }, dispose: () => { } };
         }
         const headers = [
-            ( localize(12174, "ID")),
-            ( localize(12175, "Description")),
-            ( localize(12176, "Dark Default")),
-            ( localize(12177, "Light Default")),
-            ( localize(12178, "High Contrast Default")),
+            ( localize(12509, "ID")),
+            ( localize(12510, "Description")),
+            ( localize(12511, "Dark Default")),
+            ( localize(12512, "Light Default")),
+            ( localize(12513, "High Contrast Default")),
         ];
         const toColor = (colorReference) => colorReference[0] === '#' ? ( Color.fromHex(colorReference)) : undefined;
         const rows = ( colors.sort((a, b) => a.id.localeCompare(b.id))
@@ -226,7 +226,7 @@ class ColorDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions$1.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: 'colors',
-    label: ( localize(12179, "Colors")),
+    label: ( localize(12514, "Colors")),
     access: {
         canToggle: false
     },