@codingame/monaco-vscode-api 33.0.8 → 34.0.0

package/vscode/src/vs/platform/browserView/common/browserHistory.d.ts

@@ -0,0 +1,115 @@
+import { Event } from "../../../base/common/event.js";
+import { Disposable } from "../../../base/common/lifecycle.js";
+/**
+ * On-disk shape of a single history entry.
+ * BACKWARDS COMPATIBILE. When evolving this interface, ensure older versions can still be handled gracefully.
+ */
+export interface ISerializedBrowserHistoryEntry {
+    readonly id: number;
+    readonly url: string;
+    /** Epoch ms when the entry was most recently visited. */
+    readonly time: number;
+    readonly title: string;
+    /** Content hash key into the sibling favicons map. */
+    readonly icon?: string;
+    /**
+     * Set when the navigation was initiated by the user (typing in the URL
+     * bar, picking a suggestion, opening a new tab with a URL) rather than by
+     * page script or link clicks. Always omitted when false to keep entries
+     * small.
+     */
+    readonly explicit?: true;
+}
+/**
+ * In-memory representation of a history entry. Currently identical to the
+ * on-disk shape; the split exists so future in-memory-only fields can be
+ * added here without changing the wire format.
+ */
+export interface IBrowserHistoryEntry extends ISerializedBrowserHistoryEntry {
+}
+export interface IBrowserHistoryUpdate {
+    /** URL may be updated e.g. during a redirect or in-page navigation. */
+    readonly url?: string;
+    readonly title?: string;
+    /** Favicon data URI; hashed and deduped against the sibling favicons store. Pass `null` to explicitly clear. */
+    readonly favicon?: string | null;
+}
+/**
+ * Handle returned by {@link BrowserHistoryStore.add}. `update` and `delete`
+ * are no-ops once the underlying entry has been evicted.
+ */
+export interface IBrowserHistoryItemHandle {
+    readonly id: number;
+    update(patch: IBrowserHistoryUpdate): void;
+    delete(): void;
+}
+/**
+ * On-disk shape of an entries snapshot. See {@link ISerializedBrowserHistoryEntry}
+ * for the backwards-compatibility rules; the same constraints apply here.
+ */
+export interface ISerializedBrowserHistoryEntriesSnapshot {
+    readonly items: readonly ISerializedBrowserHistoryEntry[];
+}
+/**
+ * On-disk shape of a favicons snapshot. See {@link ISerializedBrowserHistoryEntry}
+ * for the backwards-compatibility rules; the same constraints apply here.
+ */
+export interface ISerializedBrowserFaviconsSnapshot {
+    /** Map from content hash to data URI. */
+    readonly map: Readonly<Record<string, string>>;
+}
+export declare class BrowserHistoryEntriesStore extends Disposable {
+    private _nextId;
+    private _items;
+    private _maxEntries;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    constructor(maxEntries?: number);
+    get items(): readonly IBrowserHistoryEntry[];
+    get maxEntries(): number;
+    setMaxEntries(max: number): void;
+    add(url: string, title: string, faviconHash: string | undefined, userInitiated: boolean): IBrowserHistoryEntry;
+    update(id: number, patch: {
+        url?: string;
+        title?: string;
+        faviconHash?: string | null;
+    }): boolean;
+    delete(id: number): boolean;
+    clear(): void;
+    serialize(): ISerializedBrowserHistoryEntriesSnapshot;
+    hydrate(snapshot: ISerializedBrowserHistoryEntriesSnapshot | undefined): void;
+    private _indexOf;
+    private _evictIfNeeded;
+}
+/**
+ * Lives separately from {@link BrowserHistoryEntriesStore} so the (large)
+ * favicon map is only rewritten when an image is added or removed, not on
+ * every navigation.
+ */
+export declare class BrowserFaviconsStore extends Disposable {
+    private readonly _byHash;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    get(hash: string): string | undefined;
+    register(dataUri: string): string;
+    gc(referenced: ReadonlySet<string>): void;
+    clear(): void;
+    serialize(): ISerializedBrowserFaviconsSnapshot;
+    hydrate(snapshot: ISerializedBrowserFaviconsSnapshot | undefined): void;
+}
+/**
+ * Per-session browser history. The two sub-stores are exposed directly so
+ * persistence layers can flush them independently.
+ */
+export declare class BrowserHistoryStore extends Disposable {
+    readonly entries: BrowserHistoryEntriesStore;
+    readonly favicons: BrowserFaviconsStore;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    constructor(maxEntries?: number);
+    add(url: string, title: string, favicon?: string, userInitiated?: boolean): IBrowserHistoryItemHandle;
+    setMaxEntries(max: number): void;
+    clear(): void;
+    private _handleFor;
+    private _gcFavicons;
+}

package/vscode/src/vs/platform/browserView/common/browserHistory.js

@@ -0,0 +1,259 @@
+
+import { Emitter } from '../../../base/common/event.js';
+import { StringSHA1 } from '../../../base/common/hash.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+
+const NOOP_HANDLE = ( Object.freeze({
+    id: -1,
+    update: () => {},
+    delete: () => {}
+}));
+const DEFAULT_MAX_ENTRIES = 200;
+class BrowserHistoryEntriesStore extends Disposable {
+    constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+        super();
+        this._nextId = 1;
+        this._items = [];
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._maxEntries = maxEntries;
+    }
+    get items() {
+        return this._items;
+    }
+    get maxEntries() {
+        return this._maxEntries;
+    }
+    setMaxEntries(max) {
+        if (max < 0 || max === this._maxEntries) {
+            return;
+        }
+        this._maxEntries = max;
+        if (this._evictIfNeeded()) {
+            this._onDidChange.fire();
+        }
+    }
+    add(url, title, faviconHash, userInitiated) {
+        const entry = userInitiated ? {
+            id: this._nextId++,
+            url,
+            time: Date.now(),
+            title,
+            icon: faviconHash,
+            explicit: true
+        } : {
+            id: this._nextId++,
+            url,
+            time: Date.now(),
+            title,
+            icon: faviconHash
+        };
+        this._items.push(entry);
+        this._evictIfNeeded();
+        this._onDidChange.fire();
+        return entry;
+    }
+    update(id, patch) {
+        const idx = this._indexOf(id);
+        if (idx === -1) {
+            return false;
+        }
+        const existing = this._items[idx];
+        const nextTitle = patch.title && patch.title.length > 0 ? patch.title : existing.title;
+        const nextUrl = patch.url && patch.url.length > 0 ? patch.url : existing.url;
+        const nextFaviconHash = patch.faviconHash === undefined ? existing.icon : (patch.faviconHash ?? undefined);
+        if (nextUrl === existing.url && nextTitle === existing.title && nextFaviconHash === existing.icon) {
+            return false;
+        }
+        this._items[idx] = {
+            ...existing,
+            url: nextUrl,
+            title: nextTitle,
+            icon: nextFaviconHash
+        };
+        this._onDidChange.fire();
+        return true;
+    }
+    delete(id) {
+        const idx = this._indexOf(id);
+        if (idx === -1) {
+            return false;
+        }
+        this._items.splice(idx, 1);
+        this._onDidChange.fire();
+        return true;
+    }
+    clear() {
+        if (this._items.length === 0 && this._nextId === 1) {
+            return;
+        }
+        this._items = [];
+        this._nextId = 1;
+        this._onDidChange.fire();
+    }
+    serialize() {
+        return {
+            items: this._items.slice()
+        };
+    }
+    hydrate(snapshot) {
+        this._items = [];
+        this._nextId = 1;
+        if (snapshot && Array.isArray(snapshot.items)) {
+            for (const e of snapshot.items) {
+                if (isValidEntry(e)) {
+                    this._items.push(e);
+                }
+            }
+            for (const e of this._items) {
+                if (e.id >= this._nextId) {
+                    this._nextId = e.id + 1;
+                }
+            }
+            this._evictIfNeeded();
+        }
+        this._onDidChange.fire();
+    }
+    _indexOf(id) {
+        for (let i = this._items.length - 1; i >= 0; i--) {
+            if (this._items[i].id === id) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    _evictIfNeeded() {
+        if (this._items.length > this._maxEntries) {
+            this._items.splice(0, this._items.length - this._maxEntries);
+            return true;
+        }
+        return false;
+    }
+}
+class BrowserFaviconsStore extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._byHash = ( new Map());
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+    }
+    get(hash) {
+        return this._byHash.get(hash);
+    }
+    register(dataUri) {
+        const sha = ( new StringSHA1());
+        sha.update(dataUri);
+        const hash = sha.digest();
+        if (!( this._byHash.has(hash))) {
+            this._byHash.set(hash, dataUri);
+            this._onDidChange.fire();
+        }
+        return hash;
+    }
+    gc(referenced) {
+        if (this._byHash.size === 0) {
+            return;
+        }
+        let changed = false;
+        for (const hash of ( this._byHash.keys())) {
+            if (!( referenced.has(hash))) {
+                this._byHash.delete(hash);
+                changed = true;
+            }
+        }
+        if (changed) {
+            this._onDidChange.fire();
+        }
+    }
+    clear() {
+        if (this._byHash.size === 0) {
+            return;
+        }
+        this._byHash.clear();
+        this._onDidChange.fire();
+    }
+    serialize() {
+        return {
+            map: Object.fromEntries(this._byHash)
+        };
+    }
+    hydrate(snapshot) {
+        this._byHash.clear();
+        if (snapshot?.map && typeof snapshot.map === "object") {
+            for (const [k, v] of Object.entries(snapshot.map)) {
+                if (typeof v === "string") {
+                    this._byHash.set(k, v);
+                }
+            }
+        }
+        this._onDidChange.fire();
+    }
+}
+class BrowserHistoryStore extends Disposable {
+    constructor(maxEntries) {
+        super();
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.entries = this._register(( new BrowserHistoryEntriesStore(maxEntries)));
+        this.favicons = this._register(( new BrowserFaviconsStore()));
+        this._register(this.entries.onDidChange(() => {
+            this._gcFavicons();
+            this._onDidChange.fire();
+        }));
+        this._register(this.favicons.onDidChange(() => this._onDidChange.fire()));
+    }
+    add(url, title, favicon, userInitiated = false) {
+        if (this.entries.maxEntries === 0) {
+            return NOOP_HANDLE;
+        }
+        const faviconHash = favicon ? this.favicons.register(favicon) : undefined;
+        const entry = this.entries.add(url, title, faviconHash, userInitiated);
+        return this._handleFor(entry.id);
+    }
+    setMaxEntries(max) {
+        this.entries.setMaxEntries(max);
+    }
+    clear() {
+        this.entries.clear();
+        this.favicons.clear();
+    }
+    _handleFor(id) {
+        return {
+            id,
+            update: patch => {
+                const next = {};
+                if (patch.url !== undefined) {
+                    next.url = patch.url;
+                }
+                if (patch.title !== undefined) {
+                    next.title = patch.title;
+                }
+                if (patch.favicon !== undefined) {
+                    next.faviconHash = patch.favicon === null ? null : this.favicons.register(patch.favicon);
+                }
+                this.entries.update(id, next);
+            },
+            delete: () => {
+                this.entries.delete(id);
+            }
+        };
+    }
+    _gcFavicons() {
+        const referenced = ( new Set());
+        for (const e of this.entries.items) {
+            if (e.icon) {
+                referenced.add(e.icon);
+            }
+        }
+        this.favicons.gc(referenced);
+    }
+}
+function isValidEntry(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const e = value;
+    return typeof e.id === "number" && typeof e.url === "string" && typeof e.time === "number" && typeof e.title === "string" && (e.icon === undefined || typeof e.icon === "string") && (e.explicit === undefined || e.explicit === true);
+}
+
+export { BrowserFaviconsStore, BrowserHistoryEntriesStore, BrowserHistoryStore };

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

@@ -15,8 +15,13 @@ export declare enum BrowserViewCommandId {
     FocusUrlInput = "workbench.action.browser.focusUrlInput",
     OpenExternal = "workbench.action.browser.openExternal",
     OpenSettings = "workbench.action.browser.openSettings",
+    ToggleFavorite = "workbench.action.browser.toggleFavorite",
+    ShowHistory = "workbench.action.browser.showHistory",
     AddElementToChat = "workbench.action.browser.addElementToChat",
     AddConsoleLogsToChat = "workbench.action.browser.addConsoleLogsToChat",
+    AddScreenshotToChat = "workbench.action.browser.addScreenshotToChat",
+    AddAreaScreenshotToChat = "workbench.action.browser.addAreaScreenshotToChat",
+    AddFullPageScreenshotToChat = "workbench.action.browser.addFullPageScreenshotToChat",
     ToggleDevTools = "workbench.action.browser.toggleDevTools",
     ClearGlobalStorage = "workbench.action.browser.clearGlobalStorage",
     ClearWorkspaceStorage = "workbench.action.browser.clearWorkspaceStorage",
@@ -52,6 +57,12 @@ export interface IElementData {
     };
     readonly innerText?: string;
 }
+export interface IBrowserViewRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
 export interface IBrowserViewTheme {
     readonly focusBorder?: string;
     readonly buttonBackground?: string;
@@ -60,6 +71,8 @@ export interface IBrowserViewTheme {
 }
 export interface IBrowserViewConfiguration {
     readonly aiFeaturesDisabled?: boolean;
+    /** Maximum number of entries to retain per browser session history. */
+    readonly maxHistoryEntries?: number;
 }
 export interface IBrowserViewBounds {
     windowId: number;
@@ -69,21 +82,37 @@ export interface IBrowserViewBounds {
     height: number;
     zoomFactor: number;
     cornerRadius: number;
+    emulation?: {
+        scale: number;
+    };
 }
 export interface IBrowserViewCaptureScreenshotOptions {
+    /**
+     * JPEG quality from 0-100. Only applies when `format` is `'jpeg'`.
+     */
     quality?: number;
-    screenRect?: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    pageRect?: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
+    /**
+     * Encoding for the captured image. Defaults to `'jpeg'`.
+     * `'png'` is lossless (no compression artifacts) at the cost of a larger buffer.
+     */
+    format?: "jpeg" | "png";
+    screenRect?: IBrowserViewRect;
+    pageRect?: IBrowserViewRect;
+    /**
+     * When true, capture the full scrollable document, not just the visible viewport.
+     * Ignored when `screenRect` or `pageRect` is set.
+     */
+    fullPage?: boolean;
+    /**
+     * When true, wait for the next compositor frame to be presented before capturing.
+     * Use this when the caller has just torn down an in-page overlay (e.g. the area
+     * picker's dashed selection rectangle) that would otherwise still be present in
+     * the GPU surface that `capturePage` reads.
+     *
+     * Adds ~1 frame of latency (bounded by a short timeout fallback), so leave off
+     * for captures that don't follow a DOM teardown.
+     */
+    awaitNextPaint?: boolean;
 }
 /**
  * Identifies who owns a browser view's lifecycle.
@@ -130,6 +159,11 @@ export interface IBrowserViewCreateOptions {
     readonly scope: BrowserViewStorageScope;
     readonly initialState?: Partial<IBrowserViewState>;
 }
+/** `applicationSharedStorage` keys this session writes to. Empty for ephemeral sessions. */
+export interface IBrowserViewStorageKeys {
+    readonly history?: string;
+    readonly favicons?: string;
+}
 export interface IBrowserViewState {
     url: string;
     title: string;
@@ -144,8 +178,11 @@ export interface IBrowserViewState {
     lastError: IBrowserViewLoadError | undefined;
     certificateError: IBrowserViewCertificateError | undefined;
     storageScope: BrowserViewStorageScope;
+    storageKeys: IBrowserViewStorageKeys;
     browserZoomIndex: number;
     isElementSelectionActive: boolean;
+    isAreaSelectionActive: boolean;
+    device: IBrowserDeviceProfile | undefined;
 }
 export interface IBrowserViewNavigationEvent {
     url: string;
@@ -208,12 +245,7 @@ export interface IBrowserViewFindInPageOptions {
 export interface IBrowserViewFindInPageResult {
     activeMatchOrdinal: number;
     matches: number;
-    selectionArea?: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
+    selectionArea?: IBrowserViewRect;
     finalUpdate: boolean;
 }
 export declare enum BrowserViewStorageScope {
@@ -248,6 +280,16 @@ export declare const browserZoomFactors: readonly [
 export declare const browserZoomDefaultIndex: number;
 export declare function browserZoomLabel(zoomFactor: number): string;
 export declare function browserZoomAccessibilityLabel(zoomFactor: number): string;
+/**
+ * The active device emulation profile. `undefined` fields mean "use the host default" for that property.
+ */
+export interface IBrowserDeviceProfile {
+    readonly width?: number;
+    readonly height?: number;
+    readonly mobile?: boolean;
+    readonly userAgent?: string;
+    readonly deviceScaleFactor?: number;
+}
 /**
  * This should match the isolated world ID defined in `preload-browserView.ts`.
  */
@@ -272,6 +314,13 @@ export interface IBrowserViewService {
     onDynamicDidClose(id: string): Event<void>;
     onDynamicDidSelectElement(id: string): Event<IElementData>;
     onDynamicDidChangeElementSelectionActive(id: string): Event<boolean>;
+    /**
+     * Fires exactly once per area-selection session, terminating it. Receives the user-drawn
+     * rectangle on success, or `undefined` if the picker was cancelled.
+     */
+    onDynamicDidPickArea(id: string): Event<IBrowserViewRect | undefined>;
+    onDynamicDidChangeAreaSelectionActive(id: string): Event<boolean>;
+    onDynamicDidChangeDeviceEmulation(id: string): Event<IBrowserDeviceProfile | undefined>;
     /**
      * Get all known browser views with their ownership and state information.
      */
@@ -398,6 +447,8 @@ export interface IBrowserViewService {
     clearStorage(id: string): Promise<void>;
     /** Set the browser zoom index (independent from VS Code zoom). */
     setBrowserZoomIndex(id: string, zoomIndex: number): Promise<void>;
+    /** Set or clear the active device profile for a browser view. */
+    setDeviceEmulation(id: string, device: IBrowserDeviceProfile | undefined): Promise<void>;
     /**
      * Trust a certificate for a given host in the browser view's session.
      * The page will be automatically reloaded after trusting.
@@ -414,6 +465,12 @@ export interface IBrowserViewService {
      * @param fingerprint The SHA-256 fingerprint of the certificate to revoke
      */
     untrustCertificate(id: string, host: string, fingerprint: string): Promise<void>;
+    /**
+     * Delete entries from this view's session history.
+     * @param id The browser view identifier
+     * @param entryIds The IDs of the history entries to delete. If omitted, deletes all history.
+     */
+    deleteBrowserHistory(id: string, entryIds?: readonly number[]): Promise<void>;
     /**
      * Get captured console logs for a browser view.
      * Console messages are automatically captured from the moment the view is created.
@@ -430,6 +487,16 @@ export interface IBrowserViewService {
      * @param enabled Whether to enable or disable. Omit to toggle.
      */
     toggleElementSelection(id: string, enabled?: boolean): Promise<void>;
+    /**
+     * Toggle drag-to-select area picking on the top frame of a browser view.
+     * The pick result (rectangle, or `undefined` on cancellation) is delivered via
+     * {@link onDynamicDidPickArea}. UI toggle state is delivered via
+     * {@link onDynamicDidChangeAreaSelectionActive}.
+     *
+     * @param id The browser view identifier
+     * @param enabled Whether to enable or disable. Omit to toggle.
+     */
+    toggleAreaSelection(id: string, enabled?: boolean): Promise<void>;
     /**
      * Update the theme used by injected UI across all browser views.
      * @param theme The theme variables to apply
@@ -447,4 +514,16 @@ export interface IBrowserViewService {
      * @param config The configuration to apply
      */
     updateConfiguration(config: IBrowserViewConfiguration): Promise<void>;
+    /**
+     * Replace the calling window's contribution to the `file://` allowlist
+     * used by integrated browser sessions. Main unions every window's
+     * contribution into a process-wide allowlist; entries are dropped when
+     * the window is destroyed.
+     *
+     * @param windowId The calling window's `vscodeWindowId`.
+     * @param roots Normalized filesystem paths the window deems trusted —
+     * usually `getTrustedUris()` plus, when the workspace itself is trusted,
+     * its workspace folder paths.
+     */
+    updateTrustedFileRoots(windowId: number, roots: readonly string[]): Promise<void>;
 }

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

@@ -17,8 +17,13 @@ var BrowserViewCommandId;
     BrowserViewCommandId["FocusUrlInput"] = "workbench.action.browser.focusUrlInput";
     BrowserViewCommandId["OpenExternal"] = "workbench.action.browser.openExternal";
     BrowserViewCommandId["OpenSettings"] = "workbench.action.browser.openSettings";
+    BrowserViewCommandId["ToggleFavorite"] = "workbench.action.browser.toggleFavorite";
+    BrowserViewCommandId["ShowHistory"] = "workbench.action.browser.showHistory";
     BrowserViewCommandId["AddElementToChat"] = "workbench.action.browser.addElementToChat";
     BrowserViewCommandId["AddConsoleLogsToChat"] = "workbench.action.browser.addConsoleLogsToChat";
+    BrowserViewCommandId["AddScreenshotToChat"] = "workbench.action.browser.addScreenshotToChat";
+    BrowserViewCommandId["AddAreaScreenshotToChat"] = "workbench.action.browser.addAreaScreenshotToChat";
+    BrowserViewCommandId["AddFullPageScreenshotToChat"] = "workbench.action.browser.addFullPageScreenshotToChat";
     BrowserViewCommandId["ToggleDevTools"] = "workbench.action.browser.toggleDevTools";
     BrowserViewCommandId["ClearGlobalStorage"] = "workbench.action.browser.clearGlobalStorage";
     BrowserViewCommandId["ClearWorkspaceStorage"] = "workbench.action.browser.clearWorkspaceStorage";

package/vscode/src/vs/platform/configuration/common/configurationRegistry.js

@@ -82,7 +82,7 @@ class ConfigurationRegistry extends Disposable {
         this.configurationDefaultsOverrides = ( new Map());
         this.defaultLanguageConfigurationOverridesNode = {
             id: "defaultOverrides",
-            title: ( localize(1841, "Default Language Configuration Overrides")),
+            title: ( localize(1871, "Default Language Configuration Overrides")),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -283,7 +283,7 @@ class ConfigurationRegistry extends Disposable {
             type: "object",
             default: newDefaultOverride.value,
             description: ( localize(
-                1842,
+                1872,
                 "Configure settings to be overridden for {0}.",
                 getLanguageTagSettingPlainKey(key)
             )),
@@ -601,8 +601,8 @@ class ConfigurationRegistry extends Disposable {
             const overrideIdentifierProperty = `[${overrideIdentifier}]`;
             const resourceLanguagePropertiesSchema = {
                 type: "object",
-                description: ( localize(1843, "Configure editor settings to be overridden for a language.")),
-                errorMessage: ( localize(1844, "This setting does not support per-language configuration.")),
+                description: ( localize(1873, "Configure editor settings to be overridden for a language.")),
+                errorMessage: ( localize(1874, "This setting does not support per-language configuration.")),
                 $ref: resourceLanguageSettingsSchemaId
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
@@ -618,8 +618,8 @@ class ConfigurationRegistry extends Disposable {
     registerOverridePropertyPatternKey() {
         const resourceLanguagePropertiesSchema = {
             type: "object",
-            description: ( localize(1843, "Configure editor settings to be overridden for a language.")),
-            errorMessage: ( localize(1844, "This setting does not support per-language configuration.")),
+            description: ( localize(1873, "Configure editor settings to be overridden for a language.")),
+            errorMessage: ( localize(1874, "This setting does not support per-language configuration.")),
             $ref: resourceLanguageSettingsSchemaId
         };
         allSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
@@ -694,25 +694,25 @@ const configurationRegistry = ( new ConfigurationRegistry());
 Registry.add(Extensions.Configuration, configurationRegistry);
 function validateProperty(property, schema, extensionId) {
     if (!property.trim()) {
-        return localize(1845, "Cannot register an empty property");
+        return localize(1875, "Cannot register an empty property");
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
         return localize(
-            1846,
+            1876,
             "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
             property
         );
     }
     if (configurationRegistry.getConfigurationProperties()[property] !== undefined && (!extensionId || !( EXTENSION_UNIFICATION_EXTENSION_IDS.has(extensionId.toLowerCase())))) {
         return localize(
-            1847,
+            1877,
             "Cannot register '{0}'. This property is already registered.",
             property
         );
     }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
         return localize(
-            1848,
+            1878,
             "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
             property,
             schema.policy?.name,

package/vscode/src/vs/platform/contextkey/browser/contextKeyService.js

@@ -533,7 +533,7 @@ CommandsRegistry.registerCommand({
         return [...RawContextKey.all()].sort((a, b) => a.key.localeCompare(b.key));
     },
     metadata: {
-        description: ( localize(1849, "A command that returns information about context keys")),
+        description: ( localize(1879, "A command that returns information about context keys")),
         args: []
     }
 });