@codingame/monaco-vscode-a654b07e-8806-5425-b124-18f03ba8e11a-common 20.0.0

package/empty.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@codingame/monaco-vscode-a654b07e-8806-5425-b124-18f03ba8e11a-common",
+  "version": "20.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package (chat, extension-gallery, extensions, interactive, localization, mcp, notebook, remote-agent, search, terminal, view-common, walkthrough)",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common": "20.0.0",
+    "@codingame/monaco-vscode-api": "20.0.0"
+  },
+  "exports": {
+    ".": {
+      "default": "./empty.js"
+    },
+    "./vscode/*.css": {
+      "default": "./vscode/src/*.css"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

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

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IQuickPickItem } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput";
+import { IGalleryExtension } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement";
+import { IExtensionGalleryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service";
+import { ILanguagePackService } from "@codingame/monaco-vscode-api/vscode/vs/platform/languagePacks/common/languagePacks.service";
+export declare function getLocale(extension: IGalleryExtension): string | undefined;
+export interface ILanguagePackItem extends IQuickPickItem {
+    readonly extensionId?: string;
+    readonly galleryExtension?: IGalleryExtension;
+}
+export declare abstract class LanguagePackBaseService extends Disposable implements ILanguagePackService {
+    protected readonly extensionGalleryService: IExtensionGalleryService;
+    readonly _serviceBrand: undefined;
+    constructor(extensionGalleryService: IExtensionGalleryService);
+    abstract getBuiltInExtensionTranslationsUri(id: string, language: string): Promise<URI | undefined>;
+    abstract getInstalledLanguages(): Promise<Array<ILanguagePackItem>>;
+    getAvailableLanguages(): Promise<ILanguagePackItem[]>;
+    protected createQuickPickItem(locale: string, languageName?: string, languagePack?: IGalleryExtension): IQuickPickItem;
+}

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

@@ -0,0 +1,80 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { language } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IExtensionGalleryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensionManagement/common/extensionManagement.service';
+
+function getLocale(extension) {
+    return extension.tags.find(t => t.startsWith('lp-'))?.split('lp-')[1];
+}
+let LanguagePackBaseService = class LanguagePackBaseService extends Disposable {
+    constructor(extensionGalleryService) {
+        super();
+        this.extensionGalleryService = extensionGalleryService;
+    }
+    async getAvailableLanguages() {
+        const timeout = ( new CancellationTokenSource());
+        setTimeout(() => timeout.cancel(), 1000);
+        let result;
+        try {
+            result = await this.extensionGalleryService.query({
+                text: 'category:"language packs"',
+                pageSize: 20
+            }, timeout.token);
+        }
+        catch (_) {
+            return [];
+        }
+        const languagePackExtensions = result.firstPage.filter(e => e.properties.localizedLanguages?.length && ( e.tags.some(t => t.startsWith('lp-'))));
+        const allFromMarketplace = ( languagePackExtensions.map(lp => {
+            const languageName = lp.properties.localizedLanguages?.[0];
+            const locale = getLocale(lp);
+            const baseQuickPick = this.createQuickPickItem(locale, languageName, lp);
+            return {
+                ...baseQuickPick,
+                extensionId: lp.identifier.id,
+                galleryExtension: lp
+            };
+        }));
+        allFromMarketplace.push(this.createQuickPickItem('en', 'English'));
+        return allFromMarketplace;
+    }
+    createQuickPickItem(locale, languageName, languagePack) {
+        const label = languageName ?? locale;
+        let description;
+        if (label !== locale) {
+            description = `(${locale})`;
+        }
+        if (locale.toLowerCase() === language.toLowerCase()) {
+            description ??= '';
+            description += ( localize(1921, " (Current)"));
+        }
+        if (languagePack?.installCount) {
+            description ??= '';
+            const count = languagePack.installCount;
+            let countLabel;
+            if (count > 1000000) {
+                countLabel = `${Math.floor(count / 100000) / 10}M`;
+            }
+            else if (count > 1000) {
+                countLabel = `${Math.floor(count / 1000)}K`;
+            }
+            else {
+                countLabel = String(count);
+            }
+            description += ` $(cloud-download) ${countLabel}`;
+        }
+        return {
+            id: locale,
+            label,
+            description
+        };
+    }
+};
+LanguagePackBaseService = ( __decorate([
+    ( __param(0, IExtensionGalleryService))
+], LanguagePackBaseService));
+
+export { LanguagePackBaseService, getLocale };

package/vscode/src/vs/platform/observable/common/observableMemento.d.ts

@@ -0,0 +1,19 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ObservableValue } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue";
+import { StorageScope, StorageTarget } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+interface IObservableMementoOpts<T> {
+    defaultValue: T;
+    key: string;
+    toStorage?: (value: T) => string;
+    fromStorage?: (value: string) => T;
+}
+export declare function observableMemento<T>(opts: IObservableMementoOpts<T>): (scope: StorageScope, target: StorageTarget, storageService: IStorageService) => ObservableMemento<T>;
+export declare class ObservableMemento<T> extends ObservableValue<T> implements IDisposable {
+    private readonly _store;
+    private _didChange;
+    constructor(opts: IObservableMementoOpts<T>, storageScope: StorageScope, storageTarget: StorageTarget, storageService: IStorageService);
+    protected _setValue(newValue: T): void;
+    dispose(): void;
+}
+export {};

package/vscode/src/vs/platform/observable/common/observableMemento.js

@@ -0,0 +1,66 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { strictEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { DebugNameData } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/debugName';
+import { ObservableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+
+function observableMemento(opts) {
+    return (scope, target, storageService) => {
+        return ( new ObservableMemento(opts, scope, target, storageService));
+    };
+}
+let ObservableMemento = class ObservableMemento extends ObservableValue {
+    constructor(opts, storageScope, storageTarget, storageService) {
+        if (opts.defaultValue && typeof opts.defaultValue === 'object') {
+            opts.toStorage ??= (value) => JSON.stringify(value);
+            opts.fromStorage ??= (value) => JSON.parse(value);
+        }
+        let initialValue = opts.defaultValue;
+        const fromStorage = storageService.get(opts.key, storageScope);
+        if (fromStorage !== undefined) {
+            if (opts.fromStorage) {
+                try {
+                    initialValue = opts.fromStorage(fromStorage);
+                }
+                catch {
+                    initialValue = opts.defaultValue;
+                }
+            }
+        }
+        super(( new DebugNameData(undefined, `storage/${opts.key}`, undefined)), initialValue, strictEquals);
+        this._store = ( new DisposableStore());
+        this._didChange = false;
+        const didChange = storageService.onDidChangeValue(storageScope, opts.key, this._store);
+        this._store.add(didChange((e) => {
+            if (e.external && e.key === opts.key && !this._didChange) {
+                this.set(opts.defaultValue, undefined);
+            }
+        }));
+        this._store.add(storageService.onWillSaveState(() => {
+            if (this._didChange) {
+                this._didChange = false;
+                const value = this.get();
+                if (opts.toStorage) {
+                    storageService.store(opts.key, opts.toStorage(value), storageScope, storageTarget);
+                }
+                else {
+                    storageService.store(opts.key, String(value), storageScope, storageTarget);
+                }
+            }
+        }));
+    }
+    _setValue(newValue) {
+        super._setValue(newValue);
+        this._didChange = true;
+    }
+    dispose() {
+        this._store.dispose();
+    }
+};
+ObservableMemento = ( __decorate([
+    ( __param(3, IStorageService))
+], ObservableMemento));
+
+export { ObservableMemento, observableMemento };

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsIcons.d.ts

@@ -0,0 +1,24 @@
+export declare const extensionsViewIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const manageExtensionIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const clearSearchResultsIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const refreshIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const filterIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const installLocalInRemoteIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const installWorkspaceRecommendedIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const configureRecommendedIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const syncEnabledIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const syncIgnoredIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const remoteIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const installCountIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const privateExtensionIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const ratingIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const preReleaseIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const sponsorIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const starFullIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const starHalfIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const starEmptyIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const errorIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const warningIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const infoIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const trustIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const activationTimeIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionsIcons.js

@@ -0,0 +1,61 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+
+const extensionsViewIcon = registerIcon('extensions-view-icon', Codicon.extensions, ( localize(7012, 'View icon of the extensions view.')));
+const manageExtensionIcon = registerIcon('extensions-manage', Codicon.gear, ( localize(7013, 'Icon for the \'Manage\' action in the extensions view.')));
+const clearSearchResultsIcon = registerIcon('extensions-clear-search-results', Codicon.clearAll, ( localize(
+ 7014,
+ 'Icon for the \'Clear Search Result\' action in the extensions view.'
+)));
+const refreshIcon = registerIcon('extensions-refresh', Codicon.refresh, ( localize(7015, 'Icon for the \'Refresh\' action in the extensions view.')));
+const filterIcon = registerIcon('extensions-filter', Codicon.filter, ( localize(7016, 'Icon for the \'Filter\' action in the extensions view.')));
+const installLocalInRemoteIcon = registerIcon('extensions-install-local-in-remote', Codicon.cloudDownload, ( localize(
+ 7017,
+ 'Icon for the \'Install Local Extension in Remote\' action in the extensions view.'
+)));
+const installWorkspaceRecommendedIcon = registerIcon('extensions-install-workspace-recommended', Codicon.cloudDownload, ( localize(
+ 7018,
+ 'Icon for the \'Install Workspace Recommended Extensions\' action in the extensions view.'
+)));
+const configureRecommendedIcon = registerIcon('extensions-configure-recommended', Codicon.pencil, ( localize(
+ 7019,
+ 'Icon for the \'Configure Recommended Extensions\' action in the extensions view.'
+)));
+const syncEnabledIcon = registerIcon('extensions-sync-enabled', Codicon.sync, ( localize(7020, 'Icon to indicate that an extension is synced.')));
+const syncIgnoredIcon = registerIcon('extensions-sync-ignored', Codicon.syncIgnored, ( localize(7021, 'Icon to indicate that an extension is ignored when syncing.')));
+const remoteIcon = registerIcon('extensions-remote', Codicon.remote, ( localize(
+ 7022,
+ 'Icon to indicate that an extension is remote in the extensions view and editor.'
+)));
+const installCountIcon = registerIcon('extensions-install-count', Codicon.cloudDownload, ( localize(
+ 7023,
+ 'Icon shown along with the install count in the extensions view and editor.'
+)));
+const privateExtensionIcon = registerIcon('extensions-private', Codicon.lock, ( localize(
+ 7024,
+ 'Icon shown for private extensions in the extensions view and editor.'
+)));
+const ratingIcon = registerIcon('extensions-rating', Codicon.star, ( localize(
+ 7025,
+ 'Icon shown along with the rating in the extensions view and editor.'
+)));
+const preReleaseIcon = registerIcon('extensions-pre-release', Codicon.versions, ( localize(
+ 7026,
+ 'Icon shown for extensions having pre-release versions in extensions view and editor.'
+)));
+const sponsorIcon = registerIcon('extensions-sponsor', Codicon.heartFilled, ( localize(
+ 7027,
+ 'Icon used for sponsoring extensions in the extensions view and editor.'
+)));
+const starFullIcon = registerIcon('extensions-star-full', Codicon.starFull, ( localize(7028, 'Full star icon used for the rating in the extensions editor.')));
+const starHalfIcon = registerIcon('extensions-star-half', Codicon.starHalf, ( localize(7029, 'Half star icon used for the rating in the extensions editor.')));
+const starEmptyIcon = registerIcon('extensions-star-empty', Codicon.starEmpty, ( localize(7030, 'Empty star icon used for the rating in the extensions editor.')));
+const errorIcon = registerIcon('extensions-error-message', Codicon.error, ( localize(7031, 'Icon shown with a error message in the extensions editor.')));
+const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(7032, 'Icon shown with a warning message in the extensions editor.')));
+const infoIcon = registerIcon('extensions-info-message', Codicon.info, ( localize(7033, 'Icon shown with an info message in the extensions editor.')));
+const trustIcon = registerIcon('extension-workspace-trust', Codicon.shield, ( localize(7034, 'Icon shown with a workspace trust message in the extension editor.')));
+const activationTimeIcon = registerIcon('extension-activation-time', Codicon.history, ( localize(7035, 'Icon shown with a activation time message in the extension editor.')));
+
+export { activationTimeIcon, clearSearchResultsIcon, configureRecommendedIcon, errorIcon, extensionsViewIcon, filterIcon, infoIcon, installCountIcon, installLocalInRemoteIcon, installWorkspaceRecommendedIcon, manageExtensionIcon, preReleaseIcon, privateExtensionIcon, ratingIcon, refreshIcon, remoteIcon, sponsorIcon, starEmptyIcon, starFullIcon, starHalfIcon, syncEnabledIcon, syncIgnoredIcon, trustIcon, warningIcon };

package/vscode/src/vs/workbench/contrib/webview/browser/webview.d.ts

@@ -0,0 +1,127 @@
+import { Dimension } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { IMouseWheelEvent } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent";
+import { CodeWindow } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/window";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { ExtensionIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWebviewPortMapping } from "@codingame/monaco-vscode-view-common-service-override/vscode/vs/platform/webview/common/webviewPortMapping";
+export declare const KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE: RawContextKey<boolean>;
+export declare const KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED: RawContextKey<boolean>;
+export declare const KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED: RawContextKey<boolean>;
+export interface WebviewInitInfo {
+    readonly providedViewType?: string;
+    readonly origin?: string;
+    readonly title: string | undefined;
+    readonly options: WebviewOptions;
+    readonly contentOptions: WebviewContentOptions;
+    readonly extension: WebviewExtensionDescription | undefined;
+}
+export declare enum WebviewContentPurpose {
+    NotebookRenderer = "notebookRenderer",
+    CustomEditor = "customEditor",
+    WebviewView = "webviewView",
+    ChatOutputItem = "chatOutputItem"
+}
+export type WebviewStyles = {
+    readonly [key: string]: string | number;
+};
+export interface WebviewOptions {
+    readonly purpose?: WebviewContentPurpose;
+    readonly customClasses?: string;
+    readonly enableFindWidget?: boolean;
+    readonly disableServiceWorker?: boolean;
+    readonly tryRestoreScrollPosition?: boolean;
+    readonly retainContextWhenHidden?: boolean;
+    transformCssVariables?(styles: WebviewStyles): WebviewStyles;
+}
+export interface WebviewContentOptions {
+    readonly allowMultipleAPIAcquire?: boolean;
+    readonly allowScripts?: boolean;
+    readonly allowForms?: boolean;
+    readonly localResourceRoots?: readonly URI[];
+    readonly portMapping?: readonly IWebviewPortMapping[];
+    readonly enableCommandUris?: boolean | readonly string[];
+}
+export declare function areWebviewContentOptionsEqual(a: WebviewContentOptions, b: WebviewContentOptions): boolean;
+export interface WebviewExtensionDescription {
+    readonly location?: URI;
+    readonly id: ExtensionIdentifier;
+}
+export interface WebviewMessageReceivedEvent {
+    readonly message: any;
+    readonly transfer?: readonly ArrayBuffer[];
+}
+export interface IWebview extends IDisposable {
+    readonly providedViewType?: string;
+    readonly origin: string;
+    setHtml(html: string): void;
+    setTitle(title: string): void;
+    contentOptions: WebviewContentOptions;
+    localResourcesRoot: readonly URI[];
+    extension: WebviewExtensionDescription | undefined;
+    initialScrollProgress: number;
+    state: string | undefined;
+    readonly isFocused: boolean;
+    readonly onDidFocus: Event<void>;
+    readonly onDidBlur: Event<void>;
+    readonly onDidDispose: Event<void>;
+    readonly onDidClickLink: Event<string>;
+    readonly onDidScroll: Event<{
+        readonly scrollYPercentage: number;
+    }>;
+    readonly onDidWheel: Event<IMouseWheelEvent>;
+    readonly onDidUpdateState: Event<string | undefined>;
+    readonly intrinsicContentSize: IObservable<{
+        readonly width: number;
+        readonly height: number;
+    } | undefined>;
+    readonly onFatalError: Event<{
+        readonly message: string;
+    }>;
+    readonly onMissingCsp: Event<ExtensionIdentifier>;
+    readonly onMessage: Event<WebviewMessageReceivedEvent>;
+    postMessage(message: any, transfer?: readonly ArrayBuffer[]): Promise<boolean>;
+    focus(): void;
+    reload(): void;
+    showFind(animated?: boolean): void;
+    hideFind(animated?: boolean): void;
+    runFindAction(previous: boolean): void;
+    selectAll(): void;
+    copy(): void;
+    paste(): void;
+    cut(): void;
+    undo(): void;
+    redo(): void;
+    windowDidDragStart(): void;
+    windowDidDragEnd(): void;
+    setContextKeyService(scopedContextKeyService: IContextKeyService): void;
+}
+export interface IWebviewElement extends IWebview {
+    mountTo(parent: HTMLElement, targetWindow: CodeWindow): void;
+    reinitializeAfterDismount(): void;
+}
+export interface IOverlayWebview extends IWebview {
+    readonly container: HTMLElement;
+    origin: string;
+    options: WebviewOptions;
+    claim(claimant: any, targetWindow: CodeWindow, scopedContextKeyService: IContextKeyService | undefined): void;
+    release(claimant: any): void;
+    layoutWebviewOverElement(element: HTMLElement, dimension?: Dimension, clippingContainer?: HTMLElement): void;
+}
+export declare class WebviewOriginStore {
+    private readonly _memento;
+    private readonly _state;
+    constructor(rootStorageKey: string, storageService: IStorageService);
+    getOrigin(viewType: string, additionalKey: string | undefined): string;
+    private _getKey;
+}
+export declare class ExtensionKeyedWebviewOriginStore {
+    private readonly _store;
+    constructor(rootStorageKey: string, storageService: IStorageService);
+    getOrigin(viewType: string, extId: ExtensionIdentifier): string;
+}

package/vscode/src/vs/workbench/contrib/webview/browser/webview.js

@@ -0,0 +1,73 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { Memento } from '@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common/vscode/vs/workbench/common/memento';
+
+const KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE = ( new RawContextKey('webviewFindWidgetVisible', false));
+const KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED = ( new RawContextKey('webviewFindWidgetFocused', false));
+const KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED = ( new RawContextKey('webviewFindWidgetEnabled', false));
+var WebviewContentPurpose;
+(function (WebviewContentPurpose) {
+    WebviewContentPurpose["NotebookRenderer"] = "notebookRenderer";
+    WebviewContentPurpose["CustomEditor"] = "customEditor";
+    WebviewContentPurpose["WebviewView"] = "webviewView";
+    WebviewContentPurpose["ChatOutputItem"] = "chatOutputItem";
+})(WebviewContentPurpose || (WebviewContentPurpose = {}));
+function areWebviewContentOptionsEqual(a, b) {
+    return (a.allowMultipleAPIAcquire === b.allowMultipleAPIAcquire
+        && a.allowScripts === b.allowScripts
+        && a.allowForms === b.allowForms
+        && equals(a.localResourceRoots, b.localResourceRoots, isEqual)
+        && equals(a.portMapping, b.portMapping, (a, b) => a.extensionHostPort === b.extensionHostPort && a.webviewPort === b.webviewPort)
+        && areEnableCommandUrisEqual(a, b));
+}
+function areEnableCommandUrisEqual(a, b) {
+    if (a.enableCommandUris === b.enableCommandUris) {
+        return true;
+    }
+    if (Array.isArray(a.enableCommandUris) && Array.isArray(b.enableCommandUris)) {
+        return equals(a.enableCommandUris, b.enableCommandUris);
+    }
+    return false;
+}
+let WebviewOriginStore = class WebviewOriginStore {
+    constructor(rootStorageKey, storageService) {
+        this._memento = ( new Memento(rootStorageKey, storageService));
+        this._state = this._memento.getMemento(StorageScope.APPLICATION, StorageTarget.MACHINE);
+    }
+    getOrigin(viewType, additionalKey) {
+        const key = this._getKey(viewType, additionalKey);
+        const existing = this._state[key];
+        if (existing && typeof existing === 'string') {
+            return existing;
+        }
+        const newOrigin = generateUuid();
+        this._state[key] = newOrigin;
+        this._memento.saveMemento();
+        return newOrigin;
+    }
+    _getKey(viewType, additionalKey) {
+        return JSON.stringify({ viewType, key: additionalKey });
+    }
+};
+WebviewOriginStore = ( __decorate([
+    ( __param(1, IStorageService))
+], WebviewOriginStore));
+let ExtensionKeyedWebviewOriginStore = class ExtensionKeyedWebviewOriginStore {
+    constructor(rootStorageKey, storageService) {
+        this._store = ( new WebviewOriginStore(rootStorageKey, storageService));
+    }
+    getOrigin(viewType, extId) {
+        return this._store.getOrigin(viewType, extId.value);
+    }
+};
+ExtensionKeyedWebviewOriginStore = ( __decorate([
+    ( __param(1, IStorageService))
+], ExtensionKeyedWebviewOriginStore));
+
+export { ExtensionKeyedWebviewOriginStore, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE, WebviewContentPurpose, WebviewOriginStore, areWebviewContentOptionsEqual };

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionsIcons.d.ts

@@ -0,0 +1,3 @@
+export declare const extensionDefaultIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const verifiedPublisherIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const extensionVerifiedPublisherIconColor: string;

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionsIcons.js

@@ -0,0 +1,27 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerColor } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import { textLinkForeground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+
+const extensionDefaultIcon = registerIcon('extension-default-icon', Codicon.extensionsLarge, ( localize(
+ 13098,
+ 'Icon used for the default extension in the extensions view and editor.'
+)));
+const verifiedPublisherIcon = registerIcon('extensions-verified-publisher', Codicon.verifiedFilled, ( localize(
+ 13099,
+ 'Icon used for the verified extension publisher in the extensions view and editor.'
+)));
+const extensionVerifiedPublisherIconColor = registerColor('extensionIcon.verifiedForeground', textLinkForeground, ( localize(13100, "The icon color for extension verified publisher.")), false);
+
+export { extensionDefaultIcon, extensionVerifiedPublisherIconColor, verifiedPublisherIcon };