@codingame/monaco-vscode-view-common-service-override 4.5.0-improve-code-splitting.1

package/vscode/src/vs/workbench/contrib/callHierarchy/browser/callHierarchyPeek.js

@@ -0,0 +1,367 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import './media/callHierarchy.css.js';
+import { PeekViewWidget, peekViewBorder, peekViewTitleBackground, peekViewTitleForeground, peekViewTitleInfoForeground, peekViewResultsBackground, peekViewEditorMatchHighlight, IPeekViewService } from 'vscode/vscode/vs/editor/contrib/peekView/browser/peekView';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
+import { Sorter, AccessibilityProvider, IdentityProvider, VirtualDelegate, CallRenderer, DataSource } from './callHierarchyTree.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { SplitView, Sizing } from 'vscode/vscode/vs/base/browser/ui/splitview/splitview';
+import { Dimension, isKeyboardEvent } from 'vscode/vscode/vs/base/browser/dom';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { EmbeddedCodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditor/embeddedCodeEditorWidget';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { OverviewRulerLane } from 'vscode/vscode/vs/editor/common/model';
+import { themeColorFromId } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService.service';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { Color } from 'vscode/vscode/vs/base/common/color';
+import { TreeMouseEventTarget } from 'vscode/vscode/vs/base/browser/ui/tree/tree';
+import { MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions.service';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+
+var CallHierarchyTreePeekWidget_1;
+class LayoutInfo {
+    static store(info, storageService) {
+        storageService.store('callHierarchyPeekLayout', JSON.stringify(info), 0 , 1 );
+    }
+    static retrieve(storageService) {
+        const value = storageService.get('callHierarchyPeekLayout', 0 , '{}');
+        const defaultInfo = { ratio: 0.7, height: 17 };
+        try {
+            return { ...defaultInfo, ...JSON.parse(value) };
+        }
+        catch {
+            return defaultInfo;
+        }
+    }
+    constructor(ratio, height) {
+        this.ratio = ratio;
+        this.height = height;
+    }
+}
+class CallHierarchyTree extends WorkbenchAsyncDataTree {
+}
+let CallHierarchyTreePeekWidget = class CallHierarchyTreePeekWidget extends PeekViewWidget {
+    static { CallHierarchyTreePeekWidget_1 = this; }
+    static { this.TitleMenu = ( new MenuId('callhierarchy/title')); }
+    constructor(editor, _where, _direction, themeService, _peekViewService, _editorService, _textModelService, _storageService, _menuService, _contextKeyService, _instantiationService) {
+        super(editor, { showFrame: true, showArrow: true, isResizeable: true, isAccessible: true }, _instantiationService);
+        this._where = _where;
+        this._direction = _direction;
+        this._peekViewService = _peekViewService;
+        this._editorService = _editorService;
+        this._textModelService = _textModelService;
+        this._storageService = _storageService;
+        this._menuService = _menuService;
+        this._contextKeyService = _contextKeyService;
+        this._instantiationService = _instantiationService;
+        this._treeViewStates = ( new Map());
+        this._previewDisposable = ( new DisposableStore());
+        this.create();
+        this._peekViewService.addExclusiveWidget(editor, this);
+        this._applyTheme(themeService.getColorTheme());
+        this._disposables.add(themeService.onDidColorThemeChange(this._applyTheme, this));
+        this._disposables.add(this._previewDisposable);
+    }
+    dispose() {
+        LayoutInfo.store(this._layoutInfo, this._storageService);
+        this._splitView.dispose();
+        this._tree.dispose();
+        this._editor.dispose();
+        super.dispose();
+    }
+    get direction() {
+        return this._direction;
+    }
+    _applyTheme(theme) {
+        const borderColor = theme.getColor(peekViewBorder) || Color.transparent;
+        this.style({
+            arrowColor: borderColor,
+            frameColor: borderColor,
+            headerBackgroundColor: theme.getColor(peekViewTitleBackground) || Color.transparent,
+            primaryHeadingColor: theme.getColor(peekViewTitleForeground),
+            secondaryHeadingColor: theme.getColor(peekViewTitleInfoForeground)
+        });
+    }
+    _fillHead(container) {
+        super._fillHead(container, true);
+        const menu = this._menuService.createMenu(CallHierarchyTreePeekWidget_1.TitleMenu, this._contextKeyService);
+        const updateToolbar = () => {
+            const actions = [];
+            createAndFillInActionBarActions(menu, undefined, actions);
+            this._actionbarWidget.clear();
+            this._actionbarWidget.push(actions, { label: false, icon: true });
+        };
+        this._disposables.add(menu);
+        this._disposables.add(menu.onDidChange(updateToolbar));
+        updateToolbar();
+    }
+    _fillBody(parent) {
+        this._layoutInfo = LayoutInfo.retrieve(this._storageService);
+        this._dim = ( new Dimension(0, 0));
+        this._parent = parent;
+        parent.classList.add('call-hierarchy');
+        const message = document.createElement('div');
+        message.classList.add('message');
+        parent.appendChild(message);
+        this._message = message;
+        this._message.tabIndex = 0;
+        const container = document.createElement('div');
+        container.classList.add('results');
+        parent.appendChild(container);
+        this._splitView = ( new SplitView(container, { orientation: 1  }));
+        const editorContainer = document.createElement('div');
+        editorContainer.classList.add('editor');
+        container.appendChild(editorContainer);
+        const editorOptions = {
+            scrollBeyondLastLine: false,
+            scrollbar: {
+                verticalScrollbarSize: 14,
+                horizontal: 'auto',
+                useShadows: true,
+                verticalHasArrows: false,
+                horizontalHasArrows: false,
+                alwaysConsumeMouseWheel: false
+            },
+            overviewRulerLanes: 2,
+            fixedOverflowWidgets: true,
+            minimap: {
+                enabled: false
+            }
+        };
+        this._editor = this._instantiationService.createInstance(EmbeddedCodeEditorWidget, editorContainer, editorOptions, {}, this.editor);
+        const treeContainer = document.createElement('div');
+        treeContainer.classList.add('tree');
+        container.appendChild(treeContainer);
+        const options = {
+            sorter: new Sorter(),
+            accessibilityProvider: new AccessibilityProvider(() => this._direction),
+            identityProvider: new IdentityProvider(() => this._direction),
+            expandOnlyOnTwistieClick: true,
+            overrideStyles: {
+                listBackground: peekViewResultsBackground
+            }
+        };
+        this._tree = this._instantiationService.createInstance(CallHierarchyTree, 'CallHierarchyPeek', treeContainer, new VirtualDelegate(), [this._instantiationService.createInstance(CallRenderer)], this._instantiationService.createInstance(DataSource, () => this._direction), options);
+        this._splitView.addView({
+            onDidChange: Event.None,
+            element: editorContainer,
+            minimumSize: 200,
+            maximumSize: Number.MAX_VALUE,
+            layout: (width) => {
+                if (this._dim.height) {
+                    this._editor.layout({ height: this._dim.height, width });
+                }
+            }
+        }, Sizing.Distribute);
+        this._splitView.addView({
+            onDidChange: Event.None,
+            element: treeContainer,
+            minimumSize: 100,
+            maximumSize: Number.MAX_VALUE,
+            layout: (width) => {
+                if (this._dim.height) {
+                    this._tree.layout(this._dim.height, width);
+                }
+            }
+        }, Sizing.Distribute);
+        this._disposables.add(this._splitView.onDidSashChange(() => {
+            if (this._dim.width) {
+                this._layoutInfo.ratio = this._splitView.getViewSize(0) / this._dim.width;
+            }
+        }));
+        this._disposables.add(this._tree.onDidChangeFocus(this._updatePreview, this));
+        this._disposables.add(this._editor.onMouseDown(e => {
+            const { event, target } = e;
+            if (event.detail !== 2) {
+                return;
+            }
+            const [focus] = this._tree.getFocus();
+            if (!focus) {
+                return;
+            }
+            this.dispose();
+            this._editorService.openEditor({
+                resource: focus.item.uri,
+                options: { selection: target.range }
+            });
+        }));
+        this._disposables.add(this._tree.onMouseDblClick(e => {
+            if (e.target === TreeMouseEventTarget.Twistie) {
+                return;
+            }
+            if (e.element) {
+                this.dispose();
+                this._editorService.openEditor({
+                    resource: e.element.item.uri,
+                    options: { selection: e.element.item.selectionRange, pinned: true }
+                });
+            }
+        }));
+        this._disposables.add(this._tree.onDidChangeSelection(e => {
+            const [element] = e.elements;
+            if (element && isKeyboardEvent(e.browserEvent)) {
+                this.dispose();
+                this._editorService.openEditor({
+                    resource: element.item.uri,
+                    options: { selection: element.item.selectionRange, pinned: true }
+                });
+            }
+        }));
+    }
+    async _updatePreview() {
+        const [element] = this._tree.getFocus();
+        if (!element) {
+            return;
+        }
+        this._previewDisposable.clear();
+        const options = {
+            description: 'call-hierarchy-decoration',
+            stickiness: 1 ,
+            className: 'call-decoration',
+            overviewRuler: {
+                color: themeColorFromId(peekViewEditorMatchHighlight),
+                position: OverviewRulerLane.Center
+            },
+        };
+        let previewUri;
+        if (this._direction === "outgoingCalls" ) {
+            previewUri = element.parent ? element.parent.item.uri : element.model.root.uri;
+        }
+        else {
+            previewUri = element.item.uri;
+        }
+        const value = await this._textModelService.createModelReference(previewUri);
+        this._editor.setModel(value.object.textEditorModel);
+        const decorations = [];
+        let fullRange;
+        let locations = element.locations;
+        if (!locations) {
+            locations = [{ uri: element.item.uri, range: element.item.selectionRange }];
+        }
+        for (const loc of locations) {
+            if (( loc.uri.toString()) === ( previewUri.toString())) {
+                decorations.push({ range: loc.range, options });
+                fullRange = !fullRange ? loc.range : Range.plusRange(loc.range, fullRange);
+            }
+        }
+        if (fullRange) {
+            this._editor.revealRangeInCenter(fullRange, 1 );
+            const decorationsCollection = this._editor.createDecorationsCollection(decorations);
+            this._previewDisposable.add(toDisposable(() => decorationsCollection.clear()));
+        }
+        this._previewDisposable.add(value);
+        const title = this._direction === "outgoingCalls"
+            ? ( localizeWithPath(
+            'vs/workbench/contrib/callHierarchy/browser/callHierarchyPeek',
+            'callFrom',
+            "Calls from '{0}'",
+            element.model.root.name
+        ))
+            : ( localizeWithPath(
+            'vs/workbench/contrib/callHierarchy/browser/callHierarchyPeek',
+            'callsTo',
+            "Callers of '{0}'",
+            element.model.root.name
+        ));
+        this.setTitle(title);
+    }
+    showLoading() {
+        this._parent.dataset['state'] = "loading" ;
+        this.setTitle(( localizeWithPath(
+            'vs/workbench/contrib/callHierarchy/browser/callHierarchyPeek',
+            'title.loading',
+            "Loading..."
+        )));
+        this._show();
+    }
+    showMessage(message) {
+        this._parent.dataset['state'] = "message" ;
+        this.setTitle('');
+        this.setMetaTitle('');
+        this._message.innerText = message;
+        this._show();
+        this._message.focus();
+    }
+    async showModel(model) {
+        this._show();
+        const viewState = this._treeViewStates.get(this._direction);
+        await this._tree.setInput(model, viewState);
+        const root = this._tree.getNode(model).children[0];
+        await this._tree.expand(root.element);
+        if (root.children.length === 0) {
+            this.showMessage(this._direction === "outgoingCalls"
+                ? ( localizeWithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchyPeek',
+                'empt.callsFrom',
+                "No calls from '{0}'",
+                model.root.name
+            ))
+                : ( localizeWithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchyPeek',
+                'empt.callsTo',
+                "No callers of '{0}'",
+                model.root.name
+            )));
+        }
+        else {
+            this._parent.dataset['state'] = "data" ;
+            if (!viewState || this._tree.getFocus().length === 0) {
+                this._tree.setFocus([root.children[0].element]);
+            }
+            this._tree.domFocus();
+            this._updatePreview();
+        }
+    }
+    getModel() {
+        return this._tree.getInput();
+    }
+    getFocused() {
+        return this._tree.getFocus()[0];
+    }
+    async updateDirection(newDirection) {
+        const model = this._tree.getInput();
+        if (model && newDirection !== this._direction) {
+            this._treeViewStates.set(this._direction, this._tree.getViewState());
+            this._direction = newDirection;
+            await this.showModel(model);
+        }
+    }
+    _show() {
+        if (!this._isShowing) {
+            this.editor.revealLineInCenterIfOutsideViewport(this._where.lineNumber, 0 );
+            super.show(Range.fromPositions(this._where), this._layoutInfo.height);
+        }
+    }
+    _onWidth(width) {
+        if (this._dim) {
+            this._doLayoutBody(this._dim.height, width);
+        }
+    }
+    _doLayoutBody(height, width) {
+        if (this._dim.height !== height || this._dim.width !== width) {
+            super._doLayoutBody(height, width);
+            this._dim = ( new Dimension(width, height));
+            this._layoutInfo.height = this._viewZone ? this._viewZone.heightInLines : this._layoutInfo.height;
+            this._splitView.layout(width);
+            this._splitView.resizeView(0, width * this._layoutInfo.ratio);
+        }
+    }
+};
+CallHierarchyTreePeekWidget = CallHierarchyTreePeekWidget_1 = ( __decorate([
+    ( __param(3, IThemeService)),
+    ( __param(4, IPeekViewService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, ITextModelService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, IMenuService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IInstantiationService))
+], CallHierarchyTreePeekWidget));
+
+export { CallHierarchyTreePeekWidget };

package/vscode/src/vs/workbench/contrib/callHierarchy/browser/callHierarchyTree.js

@@ -0,0 +1,135 @@
+import { CallHierarchyModel } from 'vscode/vscode/vs/workbench/contrib/callHierarchy/common/callHierarchy';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { createMatches } from 'vscode/vscode/vs/base/common/filters';
+import { IconLabel } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabel';
+import { SymbolKinds } from 'vscode/vscode/vs/editor/common/languages';
+import { compare } from 'vscode/vscode/vs/base/common/strings';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+
+class Call {
+    constructor(item, locations, model, parent) {
+        this.item = item;
+        this.locations = locations;
+        this.model = model;
+        this.parent = parent;
+    }
+    static compare(a, b) {
+        let res = compare(( a.item.uri.toString()), ( b.item.uri.toString()));
+        if (res === 0) {
+            res = Range.compareRangesUsingStarts(a.item.range, b.item.range);
+        }
+        return res;
+    }
+}
+class DataSource {
+    constructor(getDirection) {
+        this.getDirection = getDirection;
+    }
+    hasChildren() {
+        return true;
+    }
+    async getChildren(element) {
+        if (element instanceof CallHierarchyModel) {
+            return ( element.roots.map(root => ( new Call(root, undefined, element, undefined))));
+        }
+        const { model, item } = element;
+        if (this.getDirection() === "outgoingCalls" ) {
+            return ( (await model.resolveOutgoingCalls(item, CancellationToken.None)).map(call => {
+                return ( new Call(call.to, ( call.fromRanges.map(range => ({ range, uri: item.uri }))), model, element));
+            }));
+        }
+        else {
+            return ( (await model.resolveIncomingCalls(item, CancellationToken.None)).map(call => {
+                return ( new Call(call.from, ( call.fromRanges.map(range => ({ range, uri: call.from.uri }))), model, element));
+            }));
+        }
+    }
+}
+class Sorter {
+    compare(element, otherElement) {
+        return Call.compare(element, otherElement);
+    }
+}
+class IdentityProvider {
+    constructor(getDirection) {
+        this.getDirection = getDirection;
+    }
+    getId(element) {
+        let res = this.getDirection() + JSON.stringify(element.item.uri) + JSON.stringify(element.item.range);
+        if (element.parent) {
+            res += this.getId(element.parent);
+        }
+        return res;
+    }
+}
+class CallRenderingTemplate {
+    constructor(icon, label) {
+        this.icon = icon;
+        this.label = label;
+    }
+}
+class CallRenderer {
+    constructor() {
+        this.templateId = CallRenderer.id;
+    }
+    static { this.id = 'CallRenderer'; }
+    renderTemplate(container) {
+        container.classList.add('callhierarchy-element');
+        const icon = document.createElement('div');
+        container.appendChild(icon);
+        const label = ( new IconLabel(container, { supportHighlights: true }));
+        return ( new CallRenderingTemplate(icon, label));
+    }
+    renderElement(node, _index, template) {
+        const { element, filterData } = node;
+        const deprecated = element.item.tags?.includes(1 );
+        template.icon.className = '';
+        template.icon.classList.add('inline', ...ThemeIcon.asClassNameArray(SymbolKinds.toIcon(element.item.kind)));
+        template.label.setLabel(element.item.name, element.item.detail, { labelEscapeNewLines: true, matches: createMatches(filterData), strikethrough: deprecated });
+    }
+    disposeTemplate(template) {
+        template.label.dispose();
+    }
+}
+class VirtualDelegate {
+    getHeight(_element) {
+        return 22;
+    }
+    getTemplateId(_element) {
+        return CallRenderer.id;
+    }
+}
+class AccessibilityProvider {
+    constructor(getDirection) {
+        this.getDirection = getDirection;
+    }
+    getWidgetAriaLabel() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/callHierarchy/browser/callHierarchyTree',
+            'tree.aria',
+            "Call Hierarchy"
+        ));
+    }
+    getAriaLabel(element) {
+        if (this.getDirection() === "outgoingCalls" ) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchyTree',
+                'from',
+                "calls from {0}",
+                element.item.name
+            ));
+        }
+        else {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/callHierarchy/browser/callHierarchyTree',
+                'to',
+                "callers of {0}",
+                element.item.name
+            ));
+        }
+    }
+}
+
+export { AccessibilityProvider, Call, CallRenderer, DataSource, IdentityProvider, Sorter, VirtualDelegate };

package/vscode/src/vs/workbench/contrib/callHierarchy/browser/media/callHierarchy.css.js

@@ -0,0 +1,6 @@
+import n from 'vscode/external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-workbench .call-hierarchy .message,.monaco-workbench .call-hierarchy .results{display:none}.monaco-workbench .call-hierarchy[data-state=data] .results{display:inherit;height:100%}.monaco-workbench .call-hierarchy[data-state=message] .message{align-items:center;display:flex;height:100%;justify-content:center}.monaco-workbench .call-hierarchy .editor,.monaco-workbench .call-hierarchy .tree{height:100%}.monaco-editor .call-hierarchy .tree{background-color:var(--vscode-peekViewResult-background);color:var(--vscode-peekViewResult-fileForeground)}.monaco-workbench .call-hierarchy .tree .callhierarchy-element{align-items:center;display:flex;flex:1;flex-flow:row nowrap}.monaco-workbench .call-hierarchy .tree .callhierarchy-element .monaco-icon-label{padding-left:4px}.monaco-editor .call-hierarchy .tree .monaco-list:focus .monaco-list-rows>.monaco-list-row.selected:not(.highlighted){background-color:var(--vscode-peekViewResult-selectionBackground);color:var(--vscode-peekViewResult-selectionForeground)!important}.monaco-editor .call-hierarchy .call-decoration{background-color:var(--vscode-peekViewEditor-matchHighlightBackground);border:2px solid var(--vscode-peekViewEditor-matchHighlightBorder);box-sizing:border-box}.monaco-editor .call-hierarchy .editor .monaco-editor .inputarea.ime-input,.monaco-editor .call-hierarchy .editor .monaco-editor .monaco-editor-background{background-color:var(--vscode-peekViewEditor-background)}.monaco-editor .call-hierarchy .editor .monaco-editor .margin{background-color:var(--vscode-peekViewEditorGutter-background)}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditor.contribution.js

@@ -0,0 +1,18 @@
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { EditorPaneDescriptor } from 'vscode/vscode/vs/workbench/browser/editor';
+import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { EditorExtensions } from 'vscode/vscode/vs/workbench/common/editor';
+import { CustomEditorInputSerializer, ComplexCustomWorkingCopyEditorHandler } from './customEditorInputFactory.js';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { WebviewEditor } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditor';
+import { CustomEditorInput } from 'vscode/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
+import './customEditors.js';
+
+( Registry.as(EditorExtensions.EditorPane))
+    .registerEditorPane(EditorPaneDescriptor.create(WebviewEditor, WebviewEditor.ID, 'Webview Editor'), [
+    ( new SyncDescriptor(CustomEditorInput))
+]);
+( Registry.as(EditorExtensions.EditorFactory))
+    .registerEditorSerializer(CustomEditorInputSerializer.ID, CustomEditorInputSerializer);
+registerWorkbenchContribution2(ComplexCustomWorkingCopyEditorHandler.ID, ComplexCustomWorkingCopyEditorHandler, 1 );

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditorInputFactory.js

@@ -0,0 +1,146 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { CustomEditorInput } from 'vscode/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
+import { ICustomEditorService } from 'vscode/vscode/vs/workbench/contrib/customEditor/common/customEditor.service';
+import { NotebookEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
+import { IWebviewService } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview.service';
+import { WebviewEditorInputSerializer, reviveWebviewExtensionDescription, restoreWebviewOptions, restoreWebviewContentOptions } from '../../webviewPanel/browser/webviewEditorInputSerializer.js';
+import { IWebviewWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.service';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service';
+import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service';
+
+let CustomEditorInputSerializer = class CustomEditorInputSerializer extends WebviewEditorInputSerializer {
+    static { this.ID = CustomEditorInput.typeId; }
+    constructor(webviewWorkbenchService, _instantiationService, _webviewService) {
+        super(webviewWorkbenchService);
+        this._instantiationService = _instantiationService;
+        this._webviewService = _webviewService;
+    }
+    serialize(input) {
+        const dirty = input.isDirty();
+        const data = {
+            ...this.toJson(input),
+            editorResource: input.resource.toJSON(),
+            dirty,
+            backupId: dirty ? input.backupId : undefined,
+        };
+        try {
+            return JSON.stringify(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    fromJson(data) {
+        return {
+            ...super.fromJson(data),
+            editorResource: ( URI.from(data.editorResource)),
+            dirty: data.dirty,
+        };
+    }
+    deserialize(_instantiationService, serializedEditorInput) {
+        const data = this.fromJson(JSON.parse(serializedEditorInput));
+        const webview = reviveWebview(this._webviewService, data);
+        const customInput = this._instantiationService.createInstance(CustomEditorInput, { resource: data.editorResource, viewType: data.viewType }, webview, { startsDirty: data.dirty, backupId: data.backupId });
+        if (typeof data.group === 'number') {
+            customInput.updateGroup(data.group);
+        }
+        return customInput;
+    }
+};
+CustomEditorInputSerializer = ( __decorate([
+    ( __param(0, IWebviewWorkbenchService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IWebviewService))
+], CustomEditorInputSerializer));
+function reviveWebview(webviewService, data) {
+    const webview = webviewService.createWebviewOverlay({
+        providedViewType: data.viewType,
+        origin: data.origin,
+        title: undefined,
+        options: {
+            purpose: "customEditor" ,
+            enableFindWidget: data.webviewOptions.enableFindWidget,
+            retainContextWhenHidden: data.webviewOptions.retainContextWhenHidden,
+        },
+        contentOptions: data.contentOptions,
+        extension: data.extension,
+    });
+    webview.state = data.state;
+    return webview;
+}
+let ComplexCustomWorkingCopyEditorHandler = class ComplexCustomWorkingCopyEditorHandler extends Disposable {
+    static { this.ID = 'workbench.contrib.complexCustomWorkingCopyEditorHandler'; }
+    constructor(_instantiationService, _workingCopyEditorService, _workingCopyBackupService, _webviewService, _customEditorService
+    ) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._workingCopyBackupService = _workingCopyBackupService;
+        this._webviewService = _webviewService;
+        this._register(_workingCopyEditorService.registerHandler(this));
+    }
+    handles(workingCopy) {
+        return workingCopy.resource.scheme === Schemas.vscodeCustomEditor;
+    }
+    isOpen(workingCopy, editor) {
+        if (!this.handles(workingCopy)) {
+            return false;
+        }
+        if (workingCopy.resource.authority === 'jupyter-notebook-ipynb' && editor instanceof NotebookEditorInput) {
+            try {
+                const data = JSON.parse(workingCopy.resource.query);
+                const workingCopyResource = ( URI.from(data));
+                return isEqual(workingCopyResource, editor.resource);
+            }
+            catch {
+                return false;
+            }
+        }
+        if (!(editor instanceof CustomEditorInput)) {
+            return false;
+        }
+        if (workingCopy.resource.authority !== editor.viewType.replace(/[^a-z0-9\-_]/gi, '-').toLowerCase()) {
+            return false;
+        }
+        try {
+            const data = JSON.parse(workingCopy.resource.query);
+            const workingCopyResource = ( URI.from(data));
+            return isEqual(workingCopyResource, editor.resource);
+        }
+        catch {
+            return false;
+        }
+    }
+    async createEditor(workingCopy) {
+        const backup = await this._workingCopyBackupService.resolve(workingCopy);
+        if (!backup?.meta) {
+            throw new Error(`No backup found for custom editor: ${workingCopy.resource}`);
+        }
+        const backupData = backup.meta;
+        const extension = reviveWebviewExtensionDescription(backupData.extension?.id, backupData.extension?.location);
+        const webview = reviveWebview(this._webviewService, {
+            viewType: backupData.viewType,
+            origin: backupData.webview.origin,
+            webviewOptions: restoreWebviewOptions(backupData.webview.options),
+            contentOptions: restoreWebviewContentOptions(backupData.webview.options),
+            state: backupData.webview.state,
+            extension,
+        });
+        const editor = this._instantiationService.createInstance(CustomEditorInput, { resource: URI.revive(backupData.editorResource), viewType: backupData.viewType }, webview, { backupId: backupData.backupId });
+        editor.updateGroup(0);
+        return editor;
+    }
+};
+ComplexCustomWorkingCopyEditorHandler = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkingCopyEditorService)),
+    ( __param(2, IWorkingCopyBackupService)),
+    ( __param(3, IWebviewService)),
+    ( __param(4, ICustomEditorService))
+], ComplexCustomWorkingCopyEditorHandler));
+
+export { ComplexCustomWorkingCopyEditorHandler, CustomEditorInputSerializer };