@codingame/monaco-vscode-api 3.2.2 → 4.0.0

package/vscode/src/vs/platform/quickinput/browser/quickInputUtils.js

@@ -1,4 +1,4 @@
-import { reset, $, EventType, isEventLike, EventHelper, createCSSRule, asCSSUrl } from '../../../base/browser/dom.js';
+import { reset, $, EventType, createCSSRule, asCSSUrl, isEventLike, EventHelper } from '../../../base/browser/dom.js';
 import { DomEmitter } from '../../../base/browser/event.js';
 import { Event } from '../../../base/common/event.js';
 import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';

package/vscode/src/vs/platform/quickinput/common/quickInput.d.ts

@@ -39,12 +39,17 @@ interface IQuickPickItem {
     highlights?: IQuickPickItemHighlights;
     buttons?: readonly IQuickInputButton[];
     picked?: boolean;
+    /**
+     * Used when we're in multi-select mode. Renders a disabled checkbox.
+     */
+    disabled?: boolean;
     alwaysShow?: boolean;
 }
 interface IQuickPickSeparator {
     type: 'separator';
     id?: string;
     label?: string;
+    description?: string;
     ariaLabel?: string;
     buttons?: readonly IQuickInputButton[];
     tooltip?: string | IMarkdownString;
@@ -170,6 +175,10 @@ interface IQuickInput extends IDisposable {
      * An event that is fired when the quick input is hidden.
      */
     readonly onDidHide: Event<IQuickInputHideEvent>;
+    /**
+     * An event that is fired when the quick input will be hidden.
+     */
+    readonly onWillHide: Event<IQuickInputHideEvent>;
     /**
      * An event that is fired when the quick input is disposed.
      */
@@ -232,6 +241,11 @@ interface IQuickInput extends IDisposable {
      * @param reason The reason why the quick input was hidden.
      */
     didHide(reason?: QuickInputHideReason): void;
+    /**
+     * Notifies that the quick input will be hidden.
+     * @param reason The reason why the quick input will be hidden.
+     */
+    willHide(reason?: QuickInputHideReason): void;
 }
 interface IQuickWidget extends IQuickInput {
     /**

package/vscode/src/vs/platform/remote/common/remoteAgentConnection.js

@@ -4,12 +4,12 @@ import { CancellationTokenSource, CancellationToken } from '../../../base/common
 import { isCancellationError, onUnexpectedError } from '../../../base/common/errors.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Disposable, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { RemoteAuthorities } from '../../../base/common/network.js';
 import { mark } from '../../../base/common/performance.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
 import { generateUuid } from '../../../base/common/uuid.js';
 import { Client, PersistentProtocol } from '../../../base/parts/ipc/common/ipc.net.js';
 import { RemoteAuthorityResolverError } from './remoteAuthorityResolver.js';
-import { getRemoteServerRootPath } from './remoteHosts.js';
 const RECONNECT_TIMEOUT = 30 * 1000 ;
 function connectionTypeToString(connectionType) {
     switch (connectionType) {
@@ -145,7 +145,7 @@ async function connectToRemoteExtensionHostAgent(options, connectionType, args,
     options.logService.trace(`${logPrefix} 1/6. invoking socketFactory.connect().`);
     let socket;
     try {
-        socket = await createSocket(options.logService, options.remoteSocketFactoryService, options.connectTo, getRemoteServerRootPath(options), `reconnectionToken=${options.reconnectionToken}&reconnection=${options.reconnectionProtocol ? 'true' : 'false'}`, connectionTypeToString(connectionType), `renderer-${connectionTypeToString(connectionType)}-${options.reconnectionToken}`, timeoutCancellationToken);
+        socket = await createSocket(options.logService, options.remoteSocketFactoryService, options.connectTo, RemoteAuthorities.getServerRootPath(), `reconnectionToken=${options.reconnectionToken}&reconnection=${options.reconnectionProtocol ? 'true' : 'false'}`, connectionTypeToString(connectionType), `renderer-${connectionTypeToString(connectionType)}-${options.reconnectionToken}`, timeoutCancellationToken);
     }
     catch (error) {
         options.logService.error(`${logPrefix} socketFactory.connect() failed or timed out. Error:`);

package/vscode/src/vs/platform/remote/common/remoteHosts.js

@@ -12,9 +12,6 @@ function getRemoteName(authority) {
     }
     return authority.substr(0, pos);
 }
-function getRemoteServerRootPath(product) {
-    return `/${product.quality ?? 'oss'}-${product.commit ?? 'dev'}`;
-}
 function parseAuthorityWithOptionalPort(authority, defaultPort) {
     let { host, port } = parseAuthority(authority);
     if (typeof port === 'undefined') {
@@ -37,4 +34,4 @@ function parseAuthority(authority) {
     }
     return { host: authority, port: undefined };
 }
-export { getRemoteAuthority, getRemoteName, getRemoteServerRootPath, parseAuthorityWithOptionalPort };
+export { getRemoteAuthority, getRemoteName, parseAuthorityWithOptionalPort };

package/vscode/src/vs/platform/secrets/common/secrets.js

@@ -1,3 +1,8 @@
+import '../../../base/common/async.js';
 import { createDecorator } from '../../instantiation/common/instantiation.js';
+import '../../storage/common/storage.js';
+import '../../../base/common/event.js';
+import '../../log/common/log.js';
+import '../../../base/common/lifecycle.js';
 const ISecretStorageService = ( createDecorator('secretStorageService'));
 export { ISecretStorageService };

package/vscode/src/vs/platform/severityIcon/browser/severityIcon.js

@@ -1,18 +1,18 @@
 import './media/severityIcon.css.js';
 import { Codicon } from '../../../base/common/codicons.js';
 import { ThemeIcon } from '../../../base/common/themables.js';
-import Severity from '../../../base/common/severity.js';
+import Severity$1 from '../../../base/common/severity.js';
 var SeverityIcon;
 ( (function(SeverityIcon) {
     function className(severity) {
         switch (severity) {
-            case Severity.Ignore:
+            case Severity$1.Ignore:
                 return 'severity-ignore ' + ThemeIcon.asClassName(Codicon.info);
-            case Severity.Info:
+            case Severity$1.Info:
                 return ThemeIcon.asClassName(Codicon.info);
-            case Severity.Warning:
+            case Severity$1.Warning:
                 return ThemeIcon.asClassName(Codicon.warning);
-            case Severity.Error:
+            case Severity$1.Error:
                 return ThemeIcon.asClassName(Codicon.error);
             default:
                 return '';

package/vscode/src/vs/platform/telemetry/common/telemetryUtils.js

@@ -1,5 +1,7 @@
 import { cloneAndChange } from '../../../base/common/objects.js';
 import { getRemoteName } from '../../remote/common/remoteHosts.js';
+import '../../../base/common/platform.js';
+import '../../../base/common/process.js';
 import { TELEMETRY_SETTING_ID, TELEMETRY_CRASH_REPORTER_SETTING_ID, TELEMETRY_OLD_SETTING_ID } from './telemetry.js';
 class TelemetryTrustedValue {
     constructor(value) {

package/vscode/src/vs/platform/terminal/common/capabilities/capabilities.d.ts

@@ -148,7 +148,7 @@ interface ICommandDetectionCapability {
     readonly currentCommand: ICurrentPartialCommand | undefined;
     readonly onCommandStarted: Event<ITerminalCommand>;
     readonly onCommandFinished: Event<ITerminalCommand>;
-    readonly onCommandExecuted: Event<void>;
+    readonly onCommandExecuted: Event<ITerminalCommand>;
     readonly onCommandInvalidated: Event<ITerminalCommand[]>;
     readonly onCurrentCommandInvalidated: Event<ICommandInvalidationRequest>;
     setCwd(value: string): void;

package/vscode/src/vs/platform/terminal/common/capabilities/commandDetectionCapability.js

@@ -350,7 +350,7 @@ class UnixPtyHeuristics extends Disposable {
         if (y === commandExecutedLine) {
             currentCommand.command += this._terminal.buffer.active.getLine(commandExecutedLine)?.translateToString(true, undefined, currentCommand.commandExecutedX) || '';
         }
-        this._hooks.onCommandExecutedEmitter.fire();
+        this._hooks.onCommandExecutedEmitter.fire(currentCommand);
     }
 }
 let WindowsPtyHeuristics = class WindowsPtyHeuristics extends Disposable {
@@ -361,21 +361,15 @@ let WindowsPtyHeuristics = class WindowsPtyHeuristics extends Disposable {
         this._hooks = _hooks;
         this._logService = _logService;
         this._onCursorMoveListener = this._register(( new MutableDisposable()));
-        this._recentlyPerformedCsiJ = false;
         this._tryAdjustCommandStartMarkerScannedLineCount = 0;
         this._tryAdjustCommandStartMarkerPollCount = 0;
         this._register(_terminal.parser.registerCsiHandler({ final: 'J' }, params => {
             if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
-                this._recentlyPerformedCsiJ = true;
                 this._hooks.clearCommandsInViewport();
             }
             return false;
         }));
         this._register(this._capability.onBeforeCommandFinished(command => {
-            if (this._recentlyPerformedCsiJ) {
-                this._recentlyPerformedCsiJ = false;
-                return;
-            }
             if (command.command.trim().toLowerCase() === 'clear' || command.command.trim().toLowerCase() === 'cls') {
                 this._tryAdjustCommandStartMarkerScheduler?.cancel();
                 this._tryAdjustCommandStartMarkerScheduler = undefined;
@@ -504,7 +498,7 @@ let WindowsPtyHeuristics = class WindowsPtyHeuristics extends Disposable {
         this._onCursorMoveListener.clear();
         this._evaluateCommandMarkers();
         this._capability.currentCommand.commandExecutedX = this._terminal.buffer.active.cursorX;
-        this._hooks.onCommandExecutedEmitter.fire();
+        this._hooks.onCommandExecutedEmitter.fire(this._capability.currentCommand);
         this._logService.debug('CommandDetectionCapability#handleCommandExecuted', this._capability.currentCommand.commandExecutedX, this._capability.currentCommand.commandExecutedMarker?.line);
     }
     preHandleCommandFinished() {
@@ -572,7 +566,7 @@ let WindowsPtyHeuristics = class WindowsPtyHeuristics extends Disposable {
             }
         }
         this._capability.currentCommand.commandExecutedMarker = this._hooks.commandMarkers[this._hooks.commandMarkers.length - 1];
-        this._hooks.onCommandExecutedEmitter.fire();
+        this._hooks.onCommandExecutedEmitter.fire(this._capability.currentCommand);
     }
     _cursorOnNextLine() {
         const lastCommand = this._capability.commands.at(-1);

package/vscode/src/vs/platform/terminal/common/terminal.d.ts

@@ -220,7 +220,7 @@ interface IShellLaunchConfig {
      * until `Terminal.show` is called. The typical usage for this is when you need to run
      * something that may need interactivity but only want to tell the user about it when
      * interaction is needed. Note that the terminals will still be exposed to all extensions
-     * as normal and they will remain hidden when the workspace is reloaded.
+     * as normal. The hidden terminals will not be restored when the workspace is next opened.
      */
     hideFromUser?: boolean;
     /**
@@ -255,6 +255,11 @@ interface IShellLaunchConfig {
      * Opt-out of the default terminal persistence on restart and reload
      */
     isTransient?: boolean;
+    /**
+     * Attempt to force shell integration to be enabled by bypassing the {@link isFeatureTerminal}
+     * equals false requirement.
+     */
+    forceShellIntegration?: boolean;
     /**
      * Create a terminal without shell integration even when it's enabled
      */

package/vscode/src/vs/platform/terminal/common/terminal.js

@@ -1,4 +1,5 @@
 import { createDecorator } from '../../instantiation/common/instantiation.js';
+import '../../contextkey/common/contextkey.js';
 import { Registry } from '../../registry/common/platform.js';
 var TitleEventSource;
 ( (function(TitleEventSource) {

package/vscode/src/vs/platform/terminal/common/terminalEnvironment.js

@@ -34,4 +34,7 @@ function sanitizeCwd(cwd) {
     }
     return cwd;
 }
-export { collapseTildePath, escapeNonWindowsPath, sanitizeCwd };
+function shouldUseEnvironmentVariableCollection(slc) {
+    return !slc.strictEnv;
+}
+export { collapseTildePath, escapeNonWindowsPath, sanitizeCwd, shouldUseEnvironmentVariableCollection };

package/vscode/src/vs/platform/theme/browser/defaultStyles.js

@@ -1,4 +1,14 @@
-import { asCssVariable, asCssVariableWithDefault, keybindingLabelBackground, keybindingLabelForeground, keybindingLabelBorder, keybindingLabelBottomBorder, widgetShadow, buttonForeground, buttonSeparator, buttonBackground, buttonHoverBackground, buttonSecondaryForeground, buttonSecondaryBackground, buttonSecondaryHoverBackground, buttonBorder, progressBarBackground, inputActiveOptionBorder, inputActiveOptionForeground, inputActiveOptionBackground, checkboxBackground, checkboxBorder, checkboxForeground, editorWidgetBackground, editorWidgetForeground, contrastBorder, problemsErrorIconForeground, problemsWarningIconForeground, problemsInfoIconForeground, textLinkForeground, inputBackground, inputForeground, inputBorder, inputValidationInfoBorder, inputValidationInfoBackground, inputValidationInfoForeground, inputValidationWarningBorder, inputValidationWarningBackground, inputValidationWarningForeground, inputValidationErrorBorder, inputValidationErrorBackground, inputValidationErrorForeground, listFilterWidgetBackground, listFilterWidgetOutline, listFilterWidgetNoMatchesOutline, listFilterWidgetShadow, badgeBackground, badgeForeground, breadcrumbsBackground, breadcrumbsForeground, breadcrumbsFocusForeground, breadcrumbsActiveSelectionForeground, listFocusBackground, listFocusForeground, listFocusOutline, listActiveSelectionBackground, listActiveSelectionForeground, listActiveSelectionIconForeground, listFocusAndSelectionOutline, listInactiveSelectionBackground, listInactiveSelectionIconForeground, listInactiveSelectionForeground, listInactiveFocusBackground, listInactiveFocusOutline, listHoverBackground, listHoverForeground, listDropOverBackground, listDropBetweenBackground, activeContrastBorder, treeIndentGuidesStroke, treeInactiveIndentGuidesStroke, tableColumnsBorder, tableOddRowsBackgroundColor, selectBackground, selectListBackground, selectForeground, pickerGroupForeground, selectBorder, focusBorder, quickInputListFocusBackground, quickInputListFocusIconForeground, quickInputListFocusForeground, editorWidgetBorder, menuBorder, menuForeground, menuBackground, menuSelectionForeground, menuSelectionBackground, menuSelectionBorder, menuSeparatorBackground, scrollbarShadow, scrollbarSliderBackground, scrollbarSliderHoverBackground, scrollbarSliderActiveBackground } from '../common/colorRegistry.js';
+import { asCssVariable, asCssVariableWithDefault } from '../common/colorUtils.js';
+import { contrastBorder, textLinkForeground, activeContrastBorder, focusBorder } from '../common/colors/baseColors.js';
+import '../common/colors/chartsColors.js';
+import { widgetShadow, editorWidgetBackground, editorWidgetForeground, problemsErrorIconForeground, problemsWarningIconForeground, problemsInfoIconForeground, breadcrumbsBackground, breadcrumbsForeground, breadcrumbsFocusForeground, breadcrumbsActiveSelectionForeground, editorWidgetBorder } from '../common/colors/editorColors.js';
+import { keybindingLabelBackground, keybindingLabelForeground, keybindingLabelBorder, keybindingLabelBottomBorder, buttonForeground, buttonSeparator, buttonBackground, buttonHoverBackground, buttonSecondaryForeground, buttonSecondaryBackground, buttonSecondaryHoverBackground, buttonBorder, inputActiveOptionBorder, inputActiveOptionForeground, inputActiveOptionBackground, checkboxBackground, checkboxBorder, checkboxForeground, inputBackground, inputForeground, inputBorder, inputValidationInfoBorder, inputValidationInfoBackground, inputValidationInfoForeground, inputValidationWarningBorder, inputValidationWarningBackground, inputValidationWarningForeground, inputValidationErrorBorder, inputValidationErrorBackground, inputValidationErrorForeground, selectBackground, selectListBackground, selectForeground, selectBorder } from '../common/colors/inputColors.js';
+import { listFilterWidgetBackground, listFilterWidgetOutline, listFilterWidgetNoMatchesOutline, listFilterWidgetShadow, listFocusBackground, listFocusForeground, listFocusOutline, listActiveSelectionBackground, listActiveSelectionForeground, listActiveSelectionIconForeground, listFocusAndSelectionOutline, listInactiveSelectionBackground, listInactiveSelectionIconForeground, listInactiveSelectionForeground, listInactiveFocusBackground, listInactiveFocusOutline, listHoverBackground, listHoverForeground, listDropOverBackground, listDropBetweenBackground, treeIndentGuidesStroke, treeInactiveIndentGuidesStroke, tableColumnsBorder, tableOddRowsBackgroundColor } from '../common/colors/listColors.js';
+import { menuBorder, menuForeground, menuBackground, menuSelectionForeground, menuSelectionBackground, menuSelectionBorder, menuSeparatorBackground } from '../common/colors/menuColors.js';
+import '../common/colors/minimapColors.js';
+import { progressBarBackground, badgeBackground, badgeForeground, scrollbarShadow, scrollbarSliderBackground, scrollbarSliderHoverBackground, scrollbarSliderActiveBackground } from '../common/colors/miscColors.js';
+import { pickerGroupForeground, quickInputListFocusBackground, quickInputListFocusIconForeground, quickInputListFocusForeground } from '../common/colors/quickpickColors.js';
+import '../common/colors/searchColors.js';
 import { Color } from '../../../base/common/color.js';
 function overrideStyles(override, styles) {
     const result = { ...styles };

package/vscode/src/vs/platform/theme/common/colorUtils.js

@@ -0,0 +1,187 @@
+import { assertNever } from '../../../base/common/assert.js';
+import { RunOnceScheduler } from '../../../base/common/async.js';
+import { Color } from '../../../base/common/color.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Extensions as Extensions$1 } from '../../jsonschemas/common/jsonContributionRegistry.js';
+import { Registry } from '../../registry/common/platform.js';
+function asCssVariableName(colorIdent) {
+    return `--vscode-${colorIdent.replace(/\./g, '-')}`;
+}
+function asCssVariable(color) {
+    return `var(${asCssVariableName(color)})`;
+}
+function asCssVariableWithDefault(color, defaultCssValue) {
+    return `var(${asCssVariableName(color)}, ${defaultCssValue})`;
+}
+const Extensions = {
+    ColorContribution: 'base.contributions.colors'
+};
+class ColorRegistry {
+    constructor() {
+        this._onDidChangeSchema = ( (new Emitter()));
+        this.onDidChangeSchema = this._onDidChangeSchema.event;
+        this.colorSchema = { type: 'object', properties: {} };
+        this.colorReferenceSchema = { type: 'string', enum: [], enumDescriptions: [] };
+        this.colorsById = {};
+    }
+    registerColor(id, defaults, description, needsTransparency = false, deprecationMessage) {
+        const colorContribution = { id, description, defaults, needsTransparency, deprecationMessage };
+        this.colorsById[id] = colorContribution;
+        const propertySchema = { type: 'string', description, format: 'color-hex', defaultSnippets: [{ body: '${1:#ff0000}' }] };
+        if (deprecationMessage) {
+            propertySchema.deprecationMessage = deprecationMessage;
+        }
+        if (needsTransparency) {
+            propertySchema.pattern = '^#(?:(?<rgba>[0-9a-fA-f]{3}[0-9a-eA-E])|(?:[0-9a-fA-F]{6}(?:(?![fF]{2})(?:[0-9a-fA-F]{2}))))?$';
+            propertySchema.patternErrorMessage = 'This color must be transparent or it will obscure content';
+        }
+        this.colorSchema.properties[id] = propertySchema;
+        this.colorReferenceSchema.enum.push(id);
+        this.colorReferenceSchema.enumDescriptions.push(description);
+        this._onDidChangeSchema.fire();
+        return id;
+    }
+    deregisterColor(id) {
+        delete this.colorsById[id];
+        delete this.colorSchema.properties[id];
+        const index = this.colorReferenceSchema.enum.indexOf(id);
+        if (index !== -1) {
+            this.colorReferenceSchema.enum.splice(index, 1);
+            this.colorReferenceSchema.enumDescriptions.splice(index, 1);
+        }
+        this._onDidChangeSchema.fire();
+    }
+    getColors() {
+        return (
+             (( (Object.keys(this.colorsById))).map(id => this.colorsById[id]))
+        );
+    }
+    resolveDefaultColor(id, theme) {
+        const colorDesc = this.colorsById[id];
+        if (colorDesc && colorDesc.defaults) {
+            const colorValue = colorDesc.defaults[theme.type];
+            return resolveColorValue(colorValue, theme);
+        }
+        return undefined;
+    }
+    getColorSchema() {
+        return this.colorSchema;
+    }
+    getColorReferenceSchema() {
+        return this.colorReferenceSchema;
+    }
+    toString() {
+        const sorter = (a, b) => {
+            const cat1 = a.indexOf('.') === -1 ? 0 : 1;
+            const cat2 = b.indexOf('.') === -1 ? 0 : 1;
+            if (cat1 !== cat2) {
+                return cat1 - cat2;
+            }
+            return a.localeCompare(b);
+        };
+        return ( (( (Object.keys(this.colorsById))).sort(sorter).map(k => `- \`${k}\`: ${this.colorsById[k].description}`))).join('\n');
+    }
+}
+const colorRegistry = ( (new ColorRegistry()));
+Registry.add(Extensions.ColorContribution, colorRegistry);
+function registerColor(id, defaults, description, needsTransparency, deprecationMessage) {
+    return colorRegistry.registerColor(id, defaults, description, needsTransparency, deprecationMessage);
+}
+function getColorRegistry() {
+    return colorRegistry;
+}
+function executeTransform(transform, theme) {
+    switch (transform.op) {
+        case 0 :
+            return resolveColorValue(transform.value, theme)?.darken(transform.factor);
+        case 1 :
+            return resolveColorValue(transform.value, theme)?.lighten(transform.factor);
+        case 2 :
+            return resolveColorValue(transform.value, theme)?.transparent(transform.factor);
+        case 3 : {
+            const backgroundColor = resolveColorValue(transform.background, theme);
+            if (!backgroundColor) {
+                return resolveColorValue(transform.value, theme);
+            }
+            return resolveColorValue(transform.value, theme)?.makeOpaque(backgroundColor);
+        }
+        case 4 :
+            for (const candidate of transform.values) {
+                const color = resolveColorValue(candidate, theme);
+                if (color) {
+                    return color;
+                }
+            }
+            return undefined;
+        case 6 :
+            return resolveColorValue(theme.defines(transform.if) ? transform.then : transform.else, theme);
+        case 5 : {
+            const from = resolveColorValue(transform.value, theme);
+            if (!from) {
+                return undefined;
+            }
+            const backgroundColor = resolveColorValue(transform.background, theme);
+            if (!backgroundColor) {
+                return (
+                     (from.transparent(transform.factor * transform.transparency))
+                );
+            }
+            return from.isDarkerThan(backgroundColor)
+                ? ( (Color.getLighterColor(from, backgroundColor, transform.factor).transparent(transform.transparency)))
+                : ( (Color.getDarkerColor(from, backgroundColor, transform.factor).transparent(transform.transparency)));
+        }
+        default:
+            throw assertNever();
+    }
+}
+function darken(colorValue, factor) {
+    return { op: 0 , value: colorValue, factor };
+}
+function lighten(colorValue, factor) {
+    return { op: 1 , value: colorValue, factor };
+}
+function transparent(colorValue, factor) {
+    return { op: 2 , value: colorValue, factor };
+}
+function opaque(colorValue, background) {
+    return { op: 3 , value: colorValue, background };
+}
+function oneOf(...colorValues) {
+    return { op: 4 , values: colorValues };
+}
+function ifDefinedThenElse(ifArg, thenArg, elseArg) {
+    return { op: 6 , if: ifArg, then: thenArg, else: elseArg };
+}
+function lessProminent(colorValue, backgroundColorValue, factor, transparency) {
+    return { op: 5 , value: colorValue, background: backgroundColorValue, factor, transparency };
+}
+function resolveColorValue(colorValue, theme) {
+    if (colorValue === null) {
+        return undefined;
+    }
+    else if (typeof colorValue === 'string') {
+        if (colorValue[0] === '#') {
+            return (
+                 (Color.fromHex(colorValue))
+            );
+        }
+        return theme.getColor(colorValue);
+    }
+    else if (colorValue instanceof Color) {
+        return colorValue;
+    }
+    else if (typeof colorValue === 'object') {
+        return executeTransform(colorValue, theme);
+    }
+    return undefined;
+}
+const workbenchColorsSchemaId = 'vscode://schemas/workbench-colors';
+const schemaRegistry = ( Registry.as(Extensions$1.JSONContribution));
+schemaRegistry.registerSchema(workbenchColorsSchemaId, colorRegistry.getColorSchema());
+const delayer = ( (new RunOnceScheduler(() => schemaRegistry.notifySchemaChanged(workbenchColorsSchemaId), 200)));
+colorRegistry.onDidChangeSchema(() => {
+    if (!delayer.isScheduled()) {
+        delayer.schedule();
+    }
+});
+export { Extensions, asCssVariable, asCssVariableName, asCssVariableWithDefault, darken, executeTransform, getColorRegistry, ifDefinedThenElse, lessProminent, lighten, oneOf, opaque, registerColor, resolveColorValue, transparent, workbenchColorsSchemaId };

package/vscode/src/vs/platform/theme/common/colors/baseColors.js

@@ -0,0 +1,89 @@
+import { localizeWithPath } from '../../../../nls.js';
+import { Color } from '../../../../base/common/color.js';
+import { registerColor, transparent } from '../colorUtils.js';
+const foreground = registerColor('foreground', { dark: '#CCCCCC', light: '#616161', hcDark: '#FFFFFF', hcLight: '#292929' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'foreground',
+ "Overall foreground color. This color is only used if not overridden by a component."
+)));
+const disabledForeground = registerColor('disabledForeground', { dark: '#CCCCCC80', light: '#61616180', hcDark: '#A5A5A5', hcLight: '#7F7F7F' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'disabledForeground',
+ "Overall foreground for disabled elements. This color is only used if not overridden by a component."
+)));
+const errorForeground = registerColor('errorForeground', { dark: '#F48771', light: '#A1260D', hcDark: '#F48771', hcLight: '#B5200D' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'errorForeground',
+ "Overall foreground color for error messages. This color is only used if not overridden by a component."
+)));
+registerColor('descriptionForeground', { light: '#717171', dark: ( transparent(foreground, 0.7)), hcDark: ( transparent(foreground, 0.7)), hcLight: ( transparent(foreground, 0.7)) }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'descriptionForeground',
+ "Foreground color for description text providing additional information, for example for a label."
+)));
+const iconForeground = registerColor('icon.foreground', { dark: '#C5C5C5', light: '#424242', hcDark: '#FFFFFF', hcLight: '#292929' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'iconForeground',
+ "The default color for icons in the workbench."
+)));
+const focusBorder = registerColor('focusBorder', { dark: '#007FD4', light: '#0090F1', hcDark: '#F38518', hcLight: '#006BBD' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'focusBorder',
+ "Overall border color for focused elements. This color is only used if not overridden by a component."
+)));
+const contrastBorder = registerColor('contrastBorder', { light: null, dark: null, hcDark: '#6FC3DF', hcLight: '#0F4A85' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'contrastBorder',
+ "An extra border around elements to separate them from others for greater contrast."
+)));
+const activeContrastBorder = registerColor('contrastActiveBorder', { light: null, dark: null, hcDark: focusBorder, hcLight: focusBorder }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'activeContrastBorder',
+ "An extra border around active elements to separate them from others for greater contrast."
+)));
+const selectionBackground = registerColor('selection.background', { light: null, dark: null, hcDark: null, hcLight: null }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'selectionBackground',
+ "The background color of text selections in the workbench (e.g. for input fields or text areas). Note that this does not apply to selections within the editor."
+)));
+const textLinkForeground = registerColor('textLink.foreground', { light: '#006AB1', dark: '#3794FF', hcDark: '#21A6FF', hcLight: '#0F4A85' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'textLinkForeground',
+ "Foreground color for links in text."
+)));
+const textLinkActiveForeground = registerColor('textLink.activeForeground', { light: '#006AB1', dark: '#3794FF', hcDark: '#21A6FF', hcLight: '#0F4A85' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'textLinkActiveForeground',
+ "Foreground color for links in text when clicked on and on mouse hover."
+)));
+registerColor('textSeparator.foreground', { light: '#0000002e', dark: '#ffffff2e', hcDark: Color.black, hcLight: '#292929' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'textSeparatorForeground',
+ "Color for text separators."
+)));
+registerColor('textPreformat.foreground', { light: '#A31515', dark: '#D7BA7D', hcDark: '#000000', hcLight: '#FFFFFF' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'textPreformatForeground',
+ "Foreground color for preformatted text segments."
+)));
+registerColor('textPreformat.background', { light: '#0000001A', dark: '#FFFFFF1A', hcDark: '#FFFFFF', hcLight: '#09345f' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'textPreformatBackground',
+ "Background color for preformatted text segments."
+)));
+const textBlockQuoteBackground = registerColor('textBlockQuote.background', { light: '#f2f2f2', dark: '#222222', hcDark: null, hcLight: '#F2F2F2' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'textBlockQuoteBackground',
+ "Background color for block quotes in text."
+)));
+const textBlockQuoteBorder = registerColor('textBlockQuote.border', { light: '#007acc80', dark: '#007acc80', hcDark: Color.white, hcLight: '#292929' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'textBlockQuoteBorder',
+ "Border color for block quotes in text."
+)));
+registerColor('textCodeBlock.background', { light: '#dcdcdc66', dark: '#0a0a0a66', hcDark: Color.black, hcLight: '#F2F2F2' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/baseColors',
+ 'textCodeBlockBackground',
+ "Background color for code blocks in text."
+)));
+export { activeContrastBorder, contrastBorder, disabledForeground, errorForeground, focusBorder, foreground, iconForeground, selectionBackground, textBlockQuoteBackground, textBlockQuoteBorder, textLinkActiveForeground, textLinkForeground };

package/vscode/src/vs/platform/theme/common/colors/chartsColors.js

@@ -0,0 +1,46 @@
+import { localizeWithPath } from '../../../../nls.js';
+import { registerColor, transparent } from '../colorUtils.js';
+import { foreground } from './baseColors.js';
+import { editorErrorForeground, editorInfoForeground, editorWarningForeground } from './editorColors.js';
+import { minimapFindMatch } from './minimapColors.js';
+registerColor('charts.foreground', { dark: foreground, light: foreground, hcDark: foreground, hcLight: foreground }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/chartsColors',
+ 'chartsForeground',
+ "The foreground color used in charts."
+)));
+registerColor('charts.lines', { dark: ( transparent(foreground, .5)), light: ( transparent(foreground, .5)), hcDark: ( transparent(foreground, .5)), hcLight: ( transparent(foreground, .5)) }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/chartsColors',
+ 'chartsLines',
+ "The color used for horizontal lines in charts."
+)));
+const chartsRed = registerColor('charts.red', { dark: editorErrorForeground, light: editorErrorForeground, hcDark: editorErrorForeground, hcLight: editorErrorForeground }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/chartsColors',
+ 'chartsRed',
+ "The red color used in chart visualizations."
+)));
+registerColor('charts.blue', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoForeground, hcLight: editorInfoForeground }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/chartsColors',
+ 'chartsBlue',
+ "The blue color used in chart visualizations."
+)));
+const chartsYellow = registerColor('charts.yellow', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningForeground, hcLight: editorWarningForeground }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/chartsColors',
+ 'chartsYellow',
+ "The yellow color used in chart visualizations."
+)));
+registerColor('charts.orange', { dark: minimapFindMatch, light: minimapFindMatch, hcDark: minimapFindMatch, hcLight: minimapFindMatch }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/chartsColors',
+ 'chartsOrange',
+ "The orange color used in chart visualizations."
+)));
+const chartsGreen = registerColor('charts.green', { dark: '#89D185', light: '#388A34', hcDark: '#89D185', hcLight: '#374e06' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/chartsColors',
+ 'chartsGreen',
+ "The green color used in chart visualizations."
+)));
+registerColor('charts.purple', { dark: '#B180D7', light: '#652D90', hcDark: '#B180D7', hcLight: '#652D90' }, ( localizeWithPath(
+ 'vs/platform/theme/common/colors/chartsColors',
+ 'chartsPurple',
+ "The purple color used in chart visualizations."
+)));
+export { chartsGreen, chartsRed, chartsYellow };