@codingame/monaco-vscode-api 1.79.7-next.1 → 1.79.7-next.2

package/dist/vscode/vs/workbench/contrib/webview/browser/webviewFindWidget.js

@@ -0,0 +1,59 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { SimpleFindWidget } from '../../codeEditor/browser/find/simpleFindWidget.js';
+import { KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED } from './webview.js';
+let WebviewFindWidget = class WebviewFindWidget extends SimpleFindWidget {
+    async _getResultCount(dataChanged) {
+        return undefined;
+    }
+    constructor(_delegate, contextViewService, contextKeyService, keybindingService) {
+        super({ showCommonFindToggles: false, checkImeCompletionState: _delegate.checkImeCompletionState }, contextViewService, contextKeyService, keybindingService);
+        this._delegate = _delegate;
+        this._findWidgetFocused = KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED.bindTo(contextKeyService);
+        this._register(_delegate.hasFindResult(hasResult => {
+            this.updateButtons(hasResult);
+            this.focusFindBox();
+        }));
+        this._register(_delegate.onDidStopFind(() => {
+            this.updateButtons(false);
+        }));
+    }
+    find(previous) {
+        const val = this.inputValue;
+        if (val) {
+            this._delegate.find(val, previous);
+        }
+    }
+    hide(animated = true) {
+        super.hide(animated);
+        this._delegate.stopFind(true);
+        this._delegate.focus();
+    }
+    _onInputChanged() {
+        const val = this.inputValue;
+        if (val) {
+            this._delegate.updateFind(val);
+        }
+        else {
+            this._delegate.stopFind(false);
+        }
+        return false;
+    }
+    _onFocusTrackerFocus() {
+        this._findWidgetFocused.set(true);
+    }
+    _onFocusTrackerBlur() {
+        this._findWidgetFocused.reset();
+    }
+    _onFindInputFocusTrackerFocus() { }
+    _onFindInputFocusTrackerBlur() { }
+    findFirst() { }
+};
+WebviewFindWidget = ( __decorate([
+    ( __param(1, IContextViewService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IKeybindingService))
+], WebviewFindWidget));
+export { WebviewFindWidget };

package/dist/vscode/vs/workbench/contrib/webview/browser/webviewService.js

@@ -0,0 +1,57 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { WebviewThemeDataProvider } from './themeing.js';
+import { WebviewElement } from './webviewElement.js';
+import { OverlayWebview } from './overlayWebview.js';
+let WebviewService = class WebviewService extends Disposable {
+    constructor(_instantiationService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._webviews = ( new Set());
+        this._onDidChangeActiveWebview = this._register(( new Emitter()));
+        this.onDidChangeActiveWebview = this._onDidChangeActiveWebview.event;
+        this._webviewThemeDataProvider = this._instantiationService.createInstance(WebviewThemeDataProvider);
+    }
+    get activeWebview() { return this._activeWebview; }
+    _updateActiveWebview(value) {
+        if (value !== this._activeWebview) {
+            this._activeWebview = value;
+            this._onDidChangeActiveWebview.fire(value);
+        }
+    }
+    get webviews() {
+        return ( this._webviews.values());
+    }
+    createWebviewElement(initInfo) {
+        const webview = this._instantiationService.createInstance(WebviewElement, initInfo, this._webviewThemeDataProvider);
+        this.registerNewWebview(webview);
+        return webview;
+    }
+    createWebviewOverlay(initInfo) {
+        const webview = this._instantiationService.createInstance(OverlayWebview, initInfo);
+        this.registerNewWebview(webview);
+        return webview;
+    }
+    registerNewWebview(webview) {
+        this._webviews.add(webview);
+        webview.onDidFocus(() => {
+            this._updateActiveWebview(webview);
+        });
+        const onBlur = () => {
+            if (this._activeWebview === webview) {
+                this._updateActiveWebview(undefined);
+            }
+        };
+        webview.onDidBlur(onBlur);
+        webview.onDidDispose(() => {
+            onBlur();
+            this._webviews.delete(webview);
+        });
+    }
+};
+WebviewService = ( __decorate([
+    ( __param(0, IInstantiationService))
+], WebviewService));
+export { WebviewService };

package/dist/vscode/vs/workbench/contrib/webview/common/webview.js

@@ -0,0 +1,39 @@
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+const webviewResourceBaseHost = 'vscode-cdn.net';
+const webviewRootResourceAuthority = `vscode-resource.${webviewResourceBaseHost}`;
+const webviewGenericCspSource = `'self' https://*.${webviewResourceBaseHost}`;
+function asWebviewUri(resource, remoteInfo) {
+    if (resource.scheme === Schemas.http || resource.scheme === Schemas.https) {
+        return resource;
+    }
+    if (remoteInfo && remoteInfo.authority && remoteInfo.isRemote && resource.scheme === Schemas.file) {
+        resource = ( URI.from({
+            scheme: Schemas.vscodeRemote,
+            authority: remoteInfo.authority,
+            path: resource.path,
+        }));
+    }
+    return ( URI.from({
+        scheme: Schemas.https,
+        authority: `${resource.scheme}+${encodeAuthority(resource.authority)}.${webviewRootResourceAuthority}`,
+        path: resource.path,
+        fragment: resource.fragment,
+        query: resource.query,
+    }));
+}
+function encodeAuthority(authority) {
+    return authority.replace(/./g, char => {
+        const code = char.charCodeAt(0);
+        if (((code >= 97  && code <= 122) )
+            || ((code >= 65  && code <= 90) )
+            || ((code >= 48  && code <= 57) )) {
+            return char;
+        }
+        return '-' + ( code.toString(16)).padStart(4, '0');
+    });
+}
+function decodeAuthority(authority) {
+    return authority.replace(/-([0-9a-f]{4})/g, (_, code) => String.fromCharCode(parseInt(code, 16)));
+}
+export { asWebviewUri, decodeAuthority, webviewGenericCspSource, webviewResourceBaseHost, webviewRootResourceAuthority };

package/dist/vscode/vs/workbench/contrib/webviewPanel/browser/webviewCommands.js

@@ -0,0 +1,120 @@
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED, IWebviewService } from '../../webview/browser/webview.js';
+import { WebviewEditor } from './webviewEditor.js';
+import { WebviewInput } from './webviewEditorInput.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+const webviewActiveContextKeyExpr = ( ContextKeyExpr.and(( ContextKeyExpr.equals('activeEditor', WebviewEditor.ID)), ( EditorContextKeys.focus.toNegated() )));
+class ShowWebViewEditorFindWidgetAction extends Action2 {
+    constructor() {
+        super({
+            id: ShowWebViewEditorFindWidgetAction.ID,
+            title: ShowWebViewEditorFindWidgetAction.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_ENABLED
+                )),
+                primary: 2048  | 36 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.showFind();
+    }
+}
+ShowWebViewEditorFindWidgetAction.ID = 'editor.action.webvieweditor.showFind';
+ShowWebViewEditorFindWidgetAction.LABEL = ( nls.localize('editor.action.webvieweditor.showFind', "Show find"));
+class HideWebViewEditorFindCommand extends Action2 {
+    constructor() {
+        super({
+            id: HideWebViewEditorFindCommand.ID,
+            title: HideWebViewEditorFindCommand.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_VISIBLE
+                )),
+                primary: 9 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.hideFind();
+    }
+}
+HideWebViewEditorFindCommand.ID = 'editor.action.webvieweditor.hideFind';
+HideWebViewEditorFindCommand.LABEL = ( nls.localize('editor.action.webvieweditor.hideFind', "Stop find"));
+class WebViewEditorFindNextCommand extends Action2 {
+    constructor() {
+        super({
+            id: WebViewEditorFindNextCommand.ID,
+            title: WebViewEditorFindNextCommand.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED
+                )),
+                primary: 3 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.runFindAction(false);
+    }
+}
+WebViewEditorFindNextCommand.ID = 'editor.action.webvieweditor.findNext';
+WebViewEditorFindNextCommand.LABEL = ( nls.localize('editor.action.webvieweditor.findNext', 'Find next'));
+class WebViewEditorFindPreviousCommand extends Action2 {
+    constructor() {
+        super({
+            id: WebViewEditorFindPreviousCommand.ID,
+            title: WebViewEditorFindPreviousCommand.LABEL,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    webviewActiveContextKeyExpr,
+                    KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED
+                )),
+                primary: 1024  | 3 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        getActiveWebviewEditor(accessor)?.runFindAction(true);
+    }
+}
+WebViewEditorFindPreviousCommand.ID = 'editor.action.webvieweditor.findPrevious';
+WebViewEditorFindPreviousCommand.LABEL = ( nls.localize('editor.action.webvieweditor.findPrevious', 'Find previous'));
+class ReloadWebviewAction extends Action2 {
+    constructor() {
+        super({
+            id: ReloadWebviewAction.ID,
+            title: { value: ReloadWebviewAction.LABEL, original: 'Reload Webviews' },
+            category: Categories.Developer,
+            menu: [{
+                    id: MenuId.CommandPalette
+                }]
+        });
+    }
+    async run(accessor) {
+        const webviewService = accessor.get(IWebviewService);
+        for (const webview of webviewService.webviews) {
+            webview.reload();
+        }
+    }
+}
+ReloadWebviewAction.ID = 'workbench.action.webview.reloadWebviewAction';
+ReloadWebviewAction.LABEL = ( nls.localize('refreshWebviewLabel', "Reload Webviews"));
+function getActiveWebviewEditor(accessor) {
+    const editorService = accessor.get(IEditorService);
+    const activeEditor = editorService.activeEditor;
+    return activeEditor instanceof WebviewInput ? activeEditor.webview : undefined;
+}
+export { HideWebViewEditorFindCommand, ReloadWebviewAction, ShowWebViewEditorFindWidgetAction, WebViewEditorFindNextCommand, WebViewEditorFindPreviousCommand };

package/dist/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditor.js

@@ -0,0 +1,170 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IContextKeyService, RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { EditorPane } from '../../../browser/parts/editor/editorPane.js';
+import { WebviewWindowDragMonitor } from '../../webview/browser/webviewWindowDragMonitor.js';
+import { WebviewInput } from './webviewEditorInput.js';
+import { IEditorDropService } from '../../../services/editor/browser/editorDropService.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+const CONTEXT_ACTIVE_WEBVIEW_PANEL_ID = ( new RawContextKey('activeWebviewPanelId', '', {
+    type: 'string',
+    description: ( nls.localize(
+        'context.activeWebviewId',
+        "The viewType of the currently active webview panel."
+    )),
+}));
+let WebviewEditor = class WebviewEditor extends EditorPane {
+    get onDidFocus() { return this._onDidFocusWebview.event; }
+    constructor(telemetryService, themeService, storageService, editorGroupsService, _editorService, _workbenchLayoutService, _editorDropService, _hostService, _contextKeyService) {
+        super(WebviewEditor.ID, telemetryService, themeService, storageService);
+        this._editorService = _editorService;
+        this._workbenchLayoutService = _workbenchLayoutService;
+        this._editorDropService = _editorDropService;
+        this._hostService = _hostService;
+        this._contextKeyService = _contextKeyService;
+        this._visible = false;
+        this._isDisposed = false;
+        this._webviewVisibleDisposables = this._register(( new DisposableStore()));
+        this._onFocusWindowHandler = this._register(( new MutableDisposable()));
+        this._onDidFocusWebview = this._register(( new Emitter()));
+        this._scopedContextKeyService = this._register(( new MutableDisposable()));
+        this._register(Event.any(editorGroupsService.onDidScroll, editorGroupsService.onDidAddGroup, editorGroupsService.onDidRemoveGroup, editorGroupsService.onDidMoveGroup)(() => {
+            if (this.webview && this._visible) {
+                this.synchronizeWebviewContainerDimensions(this.webview);
+            }
+        }));
+    }
+    get webview() {
+        return this.input instanceof WebviewInput ? this.input.webview : undefined;
+    }
+    get scopedContextKeyService() {
+        return this._scopedContextKeyService.value;
+    }
+    createEditor(parent) {
+        const element = document.createElement('div');
+        this._element = element;
+        this._element.id = `webview-editor-element-${generateUuid()}`;
+        parent.appendChild(element);
+        this._scopedContextKeyService.value = this._contextKeyService.createScoped(element);
+    }
+    dispose() {
+        this._isDisposed = true;
+        this._element?.remove();
+        this._element = undefined;
+        super.dispose();
+    }
+    layout(dimension) {
+        this._dimension = dimension;
+        if (this.webview && this._visible) {
+            this.synchronizeWebviewContainerDimensions(this.webview, dimension);
+        }
+    }
+    focus() {
+        super.focus();
+        if (!this._onFocusWindowHandler.value && !isWeb) {
+            this._onFocusWindowHandler.value = this._hostService.onDidChangeFocus(focused => {
+                if (focused && this._editorService.activeEditorPane === this && this._workbenchLayoutService.hasFocus("workbench.parts.editor" )) {
+                    this.focus();
+                }
+            });
+        }
+        this.webview?.focus();
+    }
+    setEditorVisible(visible, group) {
+        this._visible = visible;
+        if (this.input instanceof WebviewInput && this.webview) {
+            if (visible) {
+                this.claimWebview(this.input);
+            }
+            else {
+                this.webview.release(this);
+            }
+        }
+        super.setEditorVisible(visible, group);
+    }
+    clearInput() {
+        if (this.webview) {
+            this.webview.release(this);
+            this._webviewVisibleDisposables.clear();
+        }
+        super.clearInput();
+    }
+    async setInput(input, options, context, token) {
+        if (this.input && input.matches(this.input)) {
+            return;
+        }
+        const alreadyOwnsWebview = input instanceof WebviewInput && input.webview === this.webview;
+        if (this.webview && !alreadyOwnsWebview) {
+            this.webview.release(this);
+        }
+        await super.setInput(input, options, context, token);
+        await input.resolve(options);
+        if (token.isCancellationRequested || this._isDisposed) {
+            return;
+        }
+        if (input instanceof WebviewInput) {
+            if (this.group) {
+                input.updateGroup(this.group.id);
+            }
+            if (!alreadyOwnsWebview) {
+                this.claimWebview(input);
+            }
+            if (this._dimension) {
+                this.layout(this._dimension);
+            }
+        }
+    }
+    claimWebview(input) {
+        input.webview.claim(this, this.scopedContextKeyService);
+        if (this._element) {
+            this._element.setAttribute('aria-flowto', input.webview.container.id);
+            dom.setParentFlowTo(input.webview.container, this._element);
+        }
+        this._webviewVisibleDisposables.clear();
+        this._webviewVisibleDisposables.add(this._editorDropService.createEditorDropTarget(input.webview.container, {
+            containsGroup: (group) => this.group?.id === group.id
+        }));
+        this._webviewVisibleDisposables.add(( new WebviewWindowDragMonitor(() => this.webview)));
+        this.synchronizeWebviewContainerDimensions(input.webview);
+        this._webviewVisibleDisposables.add(this.trackFocus(input.webview));
+    }
+    synchronizeWebviewContainerDimensions(webview, dimension) {
+        if (!this._element?.isConnected) {
+            return;
+        }
+        const rootContainer = this._workbenchLayoutService.getContainer("workbench.parts.editor" );
+        webview.layoutWebviewOverElement(this._element.parentElement, dimension, rootContainer);
+    }
+    trackFocus(webview) {
+        const store = ( new DisposableStore());
+        const webviewContentFocusTracker = dom.trackFocus(webview.container);
+        store.add(webviewContentFocusTracker);
+        store.add(webviewContentFocusTracker.onDidFocus(() => this._onDidFocusWebview.fire()));
+        store.add(webview.onDidFocus(() => this._onDidFocusWebview.fire()));
+        return store;
+    }
+};
+WebviewEditor.ID = 'WebviewEditor';
+WebviewEditor = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IEditorGroupsService)),
+    ( __param(4, IEditorService)),
+    ( __param(5, IWorkbenchLayoutService)),
+    ( __param(6, IEditorDropService)),
+    ( __param(7, IHostService)),
+    ( __param(8, IContextKeyService))
+], WebviewEditor));
+export { CONTEXT_ACTIVE_WEBVIEW_PANEL_ID, WebviewEditor };

package/dist/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInputSerializer.js

@@ -0,0 +1,119 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { WebviewInput } from './webviewEditorInput.js';
+import { IWebviewWorkbenchService } from './webviewWorkbenchService.js';
+let WebviewEditorInputSerializer = class WebviewEditorInputSerializer {
+    constructor(_webviewWorkbenchService) {
+        this._webviewWorkbenchService = _webviewWorkbenchService;
+    }
+    canSerialize(input) {
+        return this._webviewWorkbenchService.shouldPersist(input);
+    }
+    serialize(input) {
+        if (!this._webviewWorkbenchService.shouldPersist(input)) {
+            return undefined;
+        }
+        const data = this.toJson(input);
+        try {
+            return JSON.stringify(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    deserialize(_instantiationService, serializedEditorInput) {
+        const data = this.fromJson(JSON.parse(serializedEditorInput));
+        return this._webviewWorkbenchService.openRevivedWebview({
+            webviewInitInfo: {
+                providedViewType: data.providedId,
+                origin: data.origin,
+                title: data.title,
+                options: data.webviewOptions,
+                contentOptions: data.contentOptions,
+                extension: data.extension,
+            },
+            viewType: data.viewType,
+            title: data.title,
+            iconPath: data.iconPath,
+            state: data.state,
+            group: data.group
+        });
+    }
+    fromJson(data) {
+        return {
+            ...data,
+            extension: reviveWebviewExtensionDescription(data.extensionId, data.extensionLocation),
+            iconPath: reviveIconPath(data.iconPath),
+            state: reviveState(data.state),
+            webviewOptions: restoreWebviewOptions(data.options),
+            contentOptions: restoreWebviewContentOptions(data.options),
+        };
+    }
+    toJson(input) {
+        return {
+            origin: input.webview.origin,
+            viewType: input.viewType,
+            providedId: input.providedId,
+            title: input.getName(),
+            options: { ...input.webview.options, ...input.webview.contentOptions },
+            extensionLocation: input.extension?.location,
+            extensionId: input.extension?.id.value,
+            state: input.webview.state,
+            iconPath: input.iconPath ? { light: input.iconPath.light, dark: input.iconPath.dark, } : undefined,
+            group: input.group
+        };
+    }
+};
+WebviewEditorInputSerializer.ID = WebviewInput.typeId;
+WebviewEditorInputSerializer = ( __decorate([
+    ( __param(0, IWebviewWorkbenchService))
+], WebviewEditorInputSerializer));
+function reviveWebviewExtensionDescription(extensionId, extensionLocation) {
+    if (!extensionId) {
+        return undefined;
+    }
+    const location = reviveUri(extensionLocation);
+    if (!location) {
+        return undefined;
+    }
+    return {
+        id: ( new ExtensionIdentifier(extensionId)),
+        location,
+    };
+}
+function reviveIconPath(data) {
+    if (!data) {
+        return undefined;
+    }
+    const light = reviveUri(data.light);
+    const dark = reviveUri(data.dark);
+    return light && dark ? { light, dark } : undefined;
+}
+function reviveUri(data) {
+    if (!data) {
+        return undefined;
+    }
+    try {
+        if (typeof data === 'string') {
+            return ( URI.parse(data));
+        }
+        return ( URI.from(data));
+    }
+    catch {
+        return undefined;
+    }
+}
+function reviveState(state) {
+    return typeof state === 'string' ? state : undefined;
+}
+function restoreWebviewOptions(options) {
+    return options;
+}
+function restoreWebviewContentOptions(options) {
+    return {
+        ...options,
+        localResourceRoots: options.localResourceRoots?.map(uri => reviveUri(uri)),
+    };
+}
+export { WebviewEditorInputSerializer, restoreWebviewContentOptions, restoreWebviewOptions, reviveWebviewExtensionDescription };

package/dist/vscode/vs/workbench/contrib/webviewPanel/browser/webviewIconManager.js

@@ -0,0 +1,56 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+let WebviewIconManager = class WebviewIconManager {
+    constructor(_lifecycleService, _configService) {
+        this._lifecycleService = _lifecycleService;
+        this._configService = _configService;
+        this._icons = ( new Map());
+        this._configService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('workbench.iconTheme')) {
+                this.updateStyleSheet();
+            }
+        });
+    }
+    dispose() {
+        this._styleElement?.remove();
+        this._styleElement = undefined;
+    }
+    get styleElement() {
+        if (!this._styleElement) {
+            this._styleElement = dom.createStyleSheet();
+            this._styleElement.className = 'webview-icons';
+        }
+        return this._styleElement;
+    }
+    setIcons(webviewId, iconPath) {
+        if (iconPath) {
+            this._icons.set(webviewId, iconPath);
+        }
+        else {
+            this._icons.delete(webviewId);
+        }
+        this.updateStyleSheet();
+    }
+    async updateStyleSheet() {
+        await this._lifecycleService.when(1 );
+        const cssRules = [];
+        if (this._configService.getValue('workbench.iconTheme') !== null) {
+            for (const [key, value] of this._icons) {
+                const webviewSelector = `.show-file-icons .webview-${key}-name-file-icon::before`;
+                try {
+                    cssRules.push(`.monaco-workbench.vs ${webviewSelector}, .monaco-workbench.hc-light ${webviewSelector} { content: ""; background-image: ${dom.asCSSUrl(value.light)}; }`, `.monaco-workbench.vs-dark ${webviewSelector}, .monaco-workbench.hc-black ${webviewSelector} { content: ""; background-image: ${dom.asCSSUrl(value.dark)}; }`);
+                }
+                catch {
+                }
+            }
+        }
+        this.styleElement.textContent = cssRules.join('\n');
+    }
+};
+WebviewIconManager = ( __decorate([
+    ( __param(0, ILifecycleService)),
+    ( __param(1, IConfigurationService))
+], WebviewIconManager));
+export { WebviewIconManager };