@codingame/monaco-vscode-api 26.2.1 → 27.0.0

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

@@ -4,14 +4,14 @@ import { Color } from '../../../../base/common/color.js';
 import { registerColor, transparent } from '../colorUtils.js';
 import { focusBorder, contrastBorder } from './baseColors.js';
 
-registerColor("sash.hoverBorder", focusBorder, ( localize(2341, "Border color of active sashes.")));
+registerColor("sash.hoverBorder", focusBorder, ( localize(2377, "Border color of active sashes.")));
 const badgeBackground = registerColor("badge.background", {
     dark: "#4D4D4D",
     light: "#C4C4C4",
     hcDark: Color.black,
     hcLight: "#0F4A85"
 }, ( localize(
-    2342,
+    2378,
     "Badge background color. Badges are small information labels, e.g. for search results count."
 )));
 const badgeForeground = registerColor("badge.foreground", {
@@ -20,7 +20,7 @@ const badgeForeground = registerColor("badge.foreground", {
     hcDark: Color.white,
     hcLight: Color.white
 }, ( localize(
-    2343,
+    2379,
     "Badge foreground color. Badges are small information labels, e.g. for search results count."
 )));
 const activityWarningBadgeForeground = registerColor("activityWarningBadge.foreground", {
@@ -28,57 +28,57 @@ const activityWarningBadgeForeground = registerColor("activityWarningBadge.foreg
     light: Color.white,
     hcDark: Color.white,
     hcLight: Color.white
-}, ( localize(2344, "Foreground color of the warning activity badge")));
+}, ( localize(2380, "Foreground color of the warning activity badge")));
 const activityWarningBadgeBackground = registerColor("activityWarningBadge.background", {
     dark: "#B27C00",
     light: "#B27C00",
     hcDark: null,
     hcLight: "#B27C00"
-}, ( localize(2345, "Background color of the warning activity badge")));
+}, ( localize(2381, "Background color of the warning activity badge")));
 const activityErrorBadgeForeground = registerColor("activityErrorBadge.foreground", {
     dark: ( Color.black.lighten(0.2)),
     light: Color.white,
     hcDark: null,
     hcLight: ( Color.black.lighten(0.2))
-}, ( localize(2346, "Foreground color of the error activity badge")));
+}, ( localize(2382, "Foreground color of the error activity badge")));
 const activityErrorBadgeBackground = registerColor("activityErrorBadge.background", {
     dark: "#F14C4C",
     light: "#E51400",
     hcDark: null,
     hcLight: "#F14C4C"
-}, ( localize(2347, "Background color of the error activity badge")));
+}, ( localize(2383, "Background color of the error activity badge")));
 const scrollbarShadow = registerColor("scrollbar.shadow", {
     dark: "#000000",
     light: "#DDDDDD",
     hcDark: null,
     hcLight: null
-}, ( localize(2348, "Scrollbar shadow to indicate that the view is scrolled.")));
+}, ( localize(2384, "Scrollbar shadow to indicate that the view is scrolled.")));
 const scrollbarSliderBackground = registerColor("scrollbarSlider.background", {
     dark: ( ( Color.fromHex("#797979")).transparent(0.4)),
     light: ( ( Color.fromHex("#646464")).transparent(0.4)),
     hcDark: ( transparent(contrastBorder, 0.6)),
     hcLight: ( transparent(contrastBorder, 0.4))
-}, ( localize(2349, "Scrollbar slider background color.")));
+}, ( localize(2385, "Scrollbar slider background color.")));
 const scrollbarSliderHoverBackground = registerColor("scrollbarSlider.hoverBackground", {
     dark: ( ( Color.fromHex("#646464")).transparent(0.7)),
     light: ( ( Color.fromHex("#646464")).transparent(0.7)),
     hcDark: ( transparent(contrastBorder, 0.8)),
     hcLight: ( transparent(contrastBorder, 0.8))
-}, ( localize(2350, "Scrollbar slider background color when hovering.")));
+}, ( localize(2386, "Scrollbar slider background color when hovering.")));
 const scrollbarSliderActiveBackground = registerColor("scrollbarSlider.activeBackground", {
     dark: ( ( Color.fromHex("#BFBFBF")).transparent(0.4)),
     light: ( ( Color.fromHex("#000000")).transparent(0.6)),
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(2351, "Scrollbar slider background color when clicked on.")));
-registerColor("scrollbar.background", null, ( localize(2352, "Scrollbar track background color.")));
+}, ( localize(2387, "Scrollbar slider background color when clicked on.")));
+registerColor("scrollbar.background", null, ( localize(2388, "Scrollbar track background color.")));
 const progressBarBackground = registerColor("progressBar.background", {
     dark: ( Color.fromHex("#0E70C0")),
     light: ( Color.fromHex("#0E70C0")),
     hcDark: contrastBorder,
     hcLight: contrastBorder
 }, ( localize(
-    2353,
+    2389,
     "Background color of the progress bar that can show for long running operations."
 )));
 const chartLine = registerColor("chart.line", {
@@ -86,18 +86,18 @@ const chartLine = registerColor("chart.line", {
     light: "#236B8E",
     hcDark: "#236B8E",
     hcLight: "#236B8E"
-}, ( localize(2354, "Line color for the chart.")));
+}, ( localize(2390, "Line color for the chart.")));
 const chartAxis = registerColor("chart.axis", {
     dark: ( ( Color.fromHex("#BFBFBF")).transparent(0.4)),
     light: ( ( Color.fromHex("#000000")).transparent(0.6)),
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(2355, "Axis color for the chart.")));
+}, ( localize(2391, "Axis color for the chart.")));
 const chartGuide = registerColor("chart.guide", {
     dark: ( ( Color.fromHex("#BFBFBF")).transparent(0.2)),
     light: ( ( Color.fromHex("#000000")).transparent(0.2)),
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(2356, "Guide line for the chart.")));
+}, ( localize(2392, "Guide line for the chart.")));
 
 export { activityErrorBadgeBackground, activityErrorBadgeForeground, activityWarningBadgeBackground, activityWarningBadgeForeground, badgeBackground, badgeForeground, chartAxis, chartGuide, chartLine, progressBarBackground, scrollbarShadow, scrollbarSliderActiveBackground, scrollbarSliderBackground, scrollbarSliderHoverBackground };

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

@@ -6,11 +6,11 @@ import { editorWidgetBackground, editorWidgetForeground } from './editorColors.j
 import { listActiveSelectionForeground, listActiveSelectionIconForeground, listActiveSelectionBackground } from './listColors.js';
 
 const quickInputBackground = registerColor("quickInput.background", editorWidgetBackground, ( localize(
-    2357,
+    2393,
     "Quick picker background color. The quick picker widget is the container for pickers like the command palette."
 )));
 const quickInputForeground = registerColor("quickInput.foreground", editorWidgetForeground, ( localize(
-    2358,
+    2394,
     "Quick picker foreground color. The quick picker widget is the container for pickers like the command palette."
 )));
 const quickInputTitleBackground = registerColor("quickInputTitle.background", {
@@ -19,7 +19,7 @@ const quickInputTitleBackground = registerColor("quickInputTitle.background", {
     hcDark: "#000000",
     hcLight: Color.white
 }, ( localize(
-    2359,
+    2395,
     "Quick picker title background color. The quick picker widget is the container for pickers like the command palette."
 )));
 const pickerGroupForeground = registerColor("pickerGroup.foreground", {
@@ -27,29 +27,29 @@ const pickerGroupForeground = registerColor("pickerGroup.foreground", {
     light: "#0066BF",
     hcDark: Color.white,
     hcLight: "#0F4A85"
-}, ( localize(2360, "Quick picker color for grouping labels.")));
+}, ( localize(2396, "Quick picker color for grouping labels.")));
 const pickerGroupBorder = registerColor("pickerGroup.border", {
     dark: "#3F3F46",
     light: "#CCCEDB",
     hcDark: Color.white,
     hcLight: "#0F4A85"
-}, ( localize(2361, "Quick picker color for grouping borders.")));
-const _deprecatedQuickInputListFocusBackground = registerColor("quickInput.list.focusBackground", null, "", undefined, ( localize(2362, "Please use quickInputList.focusBackground instead")));
+}, ( localize(2397, "Quick picker color for grouping borders.")));
+const _deprecatedQuickInputListFocusBackground = registerColor("quickInput.list.focusBackground", null, "", undefined, ( localize(2398, "Please use quickInputList.focusBackground instead")));
 const quickInputListFocusForeground = registerColor(
     "quickInputList.focusForeground",
     listActiveSelectionForeground,
-    ( localize(2363, "Quick picker foreground color for the focused item."))
+    ( localize(2399, "Quick picker foreground color for the focused item."))
 );
 const quickInputListFocusIconForeground = registerColor(
     "quickInputList.focusIconForeground",
     listActiveSelectionIconForeground,
-    ( localize(2364, "Quick picker icon foreground color for the focused item."))
+    ( localize(2400, "Quick picker icon foreground color for the focused item."))
 );
 const quickInputListFocusBackground = registerColor("quickInputList.focusBackground", {
     dark: oneOf(_deprecatedQuickInputListFocusBackground, listActiveSelectionBackground),
     light: oneOf(_deprecatedQuickInputListFocusBackground, listActiveSelectionBackground),
     hcDark: null,
     hcLight: null
-}, ( localize(2365, "Quick picker background color for the focused item.")));
+}, ( localize(2401, "Quick picker background color for the focused item.")));
 
 export { _deprecatedQuickInputListFocusBackground, pickerGroupBorder, pickerGroupForeground, quickInputBackground, quickInputForeground, quickInputListFocusBackground, quickInputListFocusForeground, quickInputListFocusIconForeground, quickInputTitleBackground };

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

@@ -9,16 +9,16 @@ registerColor("search.resultsInfoForeground", {
     dark: ( transparent(foreground, 0.65)),
     hcDark: foreground,
     hcLight: foreground
-}, ( localize(2366, "Color of the text in the search viewlet's completion message.")));
+}, ( localize(2402, "Color of the text in the search viewlet's completion message.")));
 registerColor("searchEditor.findMatchBackground", {
     light: ( transparent(editorFindMatchHighlight, 0.66)),
     dark: ( transparent(editorFindMatchHighlight, 0.66)),
     hcDark: editorFindMatchHighlight,
     hcLight: editorFindMatchHighlight
-}, ( localize(2367, "Color of the Search Editor query matches.")));
+}, ( localize(2403, "Color of the Search Editor query matches.")));
 registerColor("searchEditor.findMatchBorder", {
     light: ( transparent(editorFindMatchHighlightBorder, 0.66)),
     dark: ( transparent(editorFindMatchHighlightBorder, 0.66)),
     hcDark: editorFindMatchHighlightBorder,
     hcLight: editorFindMatchHighlightBorder
-}, ( localize(2368, "Border color of the Search Editor query matches.")));
+}, ( localize(2404, "Border color of the Search Editor query matches.")));

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

@@ -65,7 +65,7 @@ const fontSizeRegex = /^([\w_.%+-]+)$/;
 const fontFormatRegex = /^woff|woff2|truetype|opentype|embedded-opentype|svg$/;
 const fontColorRegex = /^#[0-9a-fA-F]{0,6}$/;
 const fontIdErrorMessage = ( localize(
-    2369,
+    2405,
     "The font ID must only contain letters, numbers, underscores and dashes."
 ));
 class IconRegistry extends Disposable {
@@ -81,7 +81,7 @@ class IconRegistry extends Disposable {
                         fontId: {
                             type: "string",
                             description: ( localize(
-                                2370,
+                                2406,
                                 "The id of the font to use. If not set, the font that is defined first is used."
                             )),
                             pattern: fontIdRegex.source,
@@ -89,7 +89,7 @@ class IconRegistry extends Disposable {
                         },
                         fontCharacter: {
                             type: "string",
-                            description: ( localize(2371, "The font character associated with the icon definition."))
+                            description: ( localize(2407, "The font character associated with the icon definition."))
                         }
                     },
                     additionalProperties: false,
@@ -245,9 +245,9 @@ iconRegistry.onDidChange(() => {
         delayer.schedule();
     }
 });
-const widgetClose = registerIcon("widget-close", Codicon.close, ( localize(2372, "Icon for the close action in widgets.")));
-const gotoPreviousLocation = registerIcon("goto-previous-location", Codicon.arrowUp, ( localize(2373, "Icon for goto previous editor location.")));
-const gotoNextLocation = registerIcon("goto-next-location", Codicon.arrowDown, ( localize(2374, "Icon for goto next editor location.")));
+const widgetClose = registerIcon("widget-close", Codicon.close, ( localize(2408, "Icon for the close action in widgets.")));
+const gotoPreviousLocation = registerIcon("goto-previous-location", Codicon.arrowUp, ( localize(2409, "Icon for goto previous editor location.")));
+const gotoNextLocation = registerIcon("goto-next-location", Codicon.arrowDown, ( localize(2410, "Icon for goto next editor location.")));
 const syncing = ThemeIcon.modify(Codicon.sync, "spin");
 const spinningLoading = ThemeIcon.modify(Codicon.loading, "spin");
 

package/vscode/src/vs/platform/theme/common/sizeRegistry.d.ts

@@ -0,0 +1,2 @@
+export * from "./sizeUtils.js";
+export * from "./sizes/baseSizes.js";

package/vscode/src/vs/platform/theme/common/sizeUtils.d.ts

@@ -0,0 +1,90 @@
+import { Event } from "../../../base/common/event.js";
+import { IJSONSchema } from "../../../base/common/jsonSchema.js";
+import { IColorTheme } from "./themeService.js";
+export type SizeIdentifier = string;
+/**
+ * Size value unit types supported by the registry
+ */
+export type SizeUnit = "px" | "rem" | "em" | "%";
+/**
+ * A size value with a numeric amount and unit
+ */
+export interface SizeValue {
+    readonly value: number;
+    readonly unit: SizeUnit;
+}
+export interface SizeContribution {
+    readonly id: SizeIdentifier;
+    readonly description: string;
+    readonly defaults: SizeDefaults | SizeValue | null;
+    readonly deprecationMessage: string | undefined;
+}
+/**
+ * Returns the css variable name for the given size identifier. Dots (`.`) are replaced with hyphens (`-`) and
+ * everything is prefixed with `--vscode-`.
+ *
+ * @sample `editor.fontSize` is `--vscode-editor-fontSize`.
+ */
+export declare function asCssVariableName(sizeIdent: SizeIdentifier): string;
+export declare function asCssVariable(size: SizeIdentifier): string;
+export declare function asCssVariableWithDefault(size: SizeIdentifier, defaultCssValue: string): string;
+export interface SizeDefaults {
+    light: SizeValue | null;
+    dark: SizeValue | null;
+    hcDark: SizeValue | null;
+    hcLight: SizeValue | null;
+}
+export declare function isSizeDefaults(value: unknown): value is SizeDefaults;
+/**
+ * Helper function to create a size value
+ */
+export declare function size(value: number, unit?: SizeUnit): SizeValue;
+/**
+ * Helper function to create size defaults that use the same value for all themes
+ */
+export declare function sizeForAllThemes(value: number, unit?: SizeUnit): SizeDefaults;
+/**
+ * Convert a size value to a CSS string
+ */
+export declare function sizeValueToCss(sizeValue: SizeValue): string;
+export declare const Extensions: {
+    SizeContribution: string;
+};
+export declare const DEFAULT_SIZE_CONFIG_VALUE = "default";
+export interface ISizeRegistry {
+    readonly onDidChangeSchema: Event<void>;
+    /**
+     * Register a size to the registry.
+     * @param id The size id as used in theme description files
+     * @param defaults The default values
+     * @param description the description
+     */
+    registerSize(id: string, defaults: SizeDefaults | SizeValue | null, description: string): SizeIdentifier;
+    /**
+     * Deregister a size from the registry.
+     */
+    deregisterSize(id: string): void;
+    /**
+     * Get all size contributions
+     */
+    getSizes(): SizeContribution[];
+    /**
+     * Gets the default size of the given id
+     */
+    resolveDefaultSize(id: SizeIdentifier, theme: IColorTheme): SizeValue | undefined;
+    /**
+     * JSON schema for an object to assign size values to one of the size contributions.
+     */
+    getSizeSchema(): IJSONSchema;
+    /**
+     * JSON schema for a reference to a size contribution.
+     */
+    getSizeReferenceSchema(): IJSONSchema;
+    /**
+     * Notify when the color theme or settings change.
+     */
+    notifyThemeUpdate(theme: IColorTheme): void;
+}
+export declare function registerSize(id: string, defaults: SizeDefaults | SizeValue | null, description: string, deprecationMessage?: string): SizeIdentifier;
+export declare function getSizeRegistry(): ISizeRegistry;
+export declare const workbenchSizesSchemaId = "vscode://schemas/workbench-sizes";

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

@@ -0,0 +1,142 @@
+
+import { Emitter } from '../../../base/common/event.js';
+import { Extensions as Extensions$1 } from '../../jsonschemas/common/jsonContributionRegistry.js';
+import { Registry } from '../../registry/common/platform.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { RunOnceScheduler } from '../../../base/common/async.js';
+
+function asCssVariableName(sizeIdent) {
+    return `--vscode-${sizeIdent.replace(/\./g, "-")}`;
+}
+function isSizeDefaults(value) {
+    return value !== null && typeof value === "object" && "light" in value && "dark" in value;
+}
+function size(value, unit = "px") {
+    return {
+        value,
+        unit
+    };
+}
+function sizeForAllThemes(value, unit = "px") {
+    const sizeValue = size(value, unit);
+    return {
+        light: sizeValue,
+        dark: sizeValue,
+        hcDark: sizeValue,
+        hcLight: sizeValue
+    };
+}
+function sizeValueToCss(sizeValue) {
+    return `${sizeValue.value}${sizeValue.unit}`;
+}
+const Extensions = {
+    SizeContribution: "base.contributions.sizes"
+};
+class SizeRegistry extends Disposable {
+    constructor() {
+        super();
+        this._onDidChangeSchema = this._register(( new Emitter()));
+        this.onDidChangeSchema = this._onDidChangeSchema.event;
+        this.sizeSchema = {
+            type: "object",
+            properties: {}
+        };
+        this.sizeReferenceSchema = {
+            type: "string",
+            enum: [],
+            enumDescriptions: []
+        };
+        this.sizesById = {};
+    }
+    notifyThemeUpdate(theme) {
+        for (const key of ( Object.keys(this.sizesById))) {
+            const sizeVal = this.resolveDefaultSize(key, theme);
+            if (sizeVal) {
+                this.sizeSchema.properties[key].default = sizeValueToCss(sizeVal);
+            }
+        }
+        this._onDidChangeSchema.fire();
+    }
+    registerSize(id, defaults, description, deprecationMessage) {
+        const sizeContribution = {
+            id,
+            description,
+            defaults,
+            deprecationMessage
+        };
+        this.sizesById[id] = sizeContribution;
+        const propertySchema = {
+            type: "string",
+            pattern: "^(\\d+(\\.\\d+)?(px|rem|em|%))|default$",
+            patternErrorMessage: "Size must be a number followed by px, rem, em, or % (e.g., \"12px\", \"1.5rem\") or \"default\""
+        };
+        if (deprecationMessage) {
+            propertySchema.deprecationMessage = deprecationMessage;
+        }
+        this.sizeSchema.properties[id] = {
+            description,
+            ...propertySchema
+        };
+        this.sizeReferenceSchema.enum.push(id);
+        this.sizeReferenceSchema.enumDescriptions.push(description);
+        this._onDidChangeSchema.fire();
+        return id;
+    }
+    deregisterSize(id) {
+        delete this.sizesById[id];
+        delete this.sizeSchema.properties[id];
+        const index = this.sizeReferenceSchema.enum.indexOf(id);
+        if (index !== -1) {
+            this.sizeReferenceSchema.enum.splice(index, 1);
+            this.sizeReferenceSchema.enumDescriptions.splice(index, 1);
+        }
+        this._onDidChangeSchema.fire();
+    }
+    getSizes() {
+        return ( ( Object.keys(this.sizesById)).map(id => this.sizesById[id]));
+    }
+    resolveDefaultSize(id, theme) {
+        const sizeDesc = this.sizesById[id];
+        if (sizeDesc?.defaults) {
+            const sizeValue = isSizeDefaults(sizeDesc.defaults) ? sizeDesc.defaults[theme.type] : sizeDesc.defaults;
+            return sizeValue ?? undefined;
+        }
+        return undefined;
+    }
+    getSizeSchema() {
+        return this.sizeSchema;
+    }
+    getSizeReferenceSchema() {
+        return this.sizeReferenceSchema;
+    }
+    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.sizesById)).sort(sorter).map(k => `- \`${k}\`: ${this.sizesById[k].description}`)).join("\n");
+    }
+}
+const sizeRegistry = ( new SizeRegistry());
+Registry.add(Extensions.SizeContribution, sizeRegistry);
+function registerSize(id, defaults, description, deprecationMessage) {
+    return sizeRegistry.registerSize(id, defaults, description, deprecationMessage);
+}
+function getSizeRegistry() {
+    return sizeRegistry;
+}
+const workbenchSizesSchemaId = "vscode://schemas/workbench-sizes";
+const schemaRegistry = Registry.as(Extensions$1.JSONContribution);
+schemaRegistry.registerSchema(workbenchSizesSchemaId, sizeRegistry.getSizeSchema());
+const delayer = ( new RunOnceScheduler(() => schemaRegistry.notifySchemaChanged(workbenchSizesSchemaId), 200));
+sizeRegistry.onDidChangeSchema(() => {
+    if (!delayer.isScheduled()) {
+        delayer.schedule();
+    }
+});
+
+export { Extensions, asCssVariableName, getSizeRegistry, isSizeDefaults, registerSize, size, sizeForAllThemes, sizeValueToCss, workbenchSizesSchemaId };

package/vscode/src/vs/platform/theme/common/sizes/baseSizes.d.ts

@@ -0,0 +1,11 @@
+export declare const bodyFontSize: string;
+export declare const bodyFontSizeSmall: string;
+export declare const bodyFontSizeXSmall: string;
+export declare const codiconFontSize: string;
+export declare const cornerRadiusMedium: string;
+export declare const cornerRadiusXSmall: string;
+export declare const cornerRadiusSmall: string;
+export declare const cornerRadiusLarge: string;
+export declare const cornerRadiusXLarge: string;
+export declare const cornerRadiusCircle: string;
+export declare const strokeThickness: string;

package/vscode/src/vs/platform/theme/common/sizes/baseSizes.js

@@ -0,0 +1,18 @@
+
+import { localize } from '../../../../nls.js';
+import { registerSize, sizeForAllThemes } from '../sizeUtils.js';
+
+registerSize("bodyFontSize", sizeForAllThemes(13, "px"), ( localize(
+    2411,
+    "Base font size. This size is used if not overridden by a component."
+)));
+registerSize("bodyFontSize.small", sizeForAllThemes(12, "px"), ( localize(2412, "Small font size for secondary content.")));
+registerSize("bodyFontSize.xSmall", sizeForAllThemes(11, "px"), ( localize(2413, "Extra small font size for less prominent content.")));
+registerSize("codiconFontSize", sizeForAllThemes(16, "px"), ( localize(2414, "Base font size for codicons.")));
+registerSize("cornerRadius.medium", sizeForAllThemes(6, "px"), ( localize(2415, "Base corner radius for UI elements.")));
+registerSize("cornerRadius.xSmall", sizeForAllThemes(2, "px"), ( localize(2416, "Extra small corner radius for very compact UI elements.")));
+registerSize("cornerRadius.small", sizeForAllThemes(4, "px"), ( localize(2417, "Small corner radius for compact UI elements.")));
+registerSize("cornerRadius.large", sizeForAllThemes(8, "px"), ( localize(2418, "Large corner radius for prominent UI elements.")));
+registerSize("cornerRadius.xLarge", sizeForAllThemes(12, "px"), ( localize(2419, "Extra large corner radius for very prominent UI elements.")));
+registerSize("cornerRadius.circle", sizeForAllThemes(9999, "px"), ( localize(2420, "Circular corner radius for fully rounded UI elements.")));
+registerSize("strokeThickness", sizeForAllThemes(1, "px"), ( localize(2421, "Base stroke thickness for borders and outlines.")));