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

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

@@ -1,59 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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 };