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

package/dist/vscode/vs/workbench/contrib/codeEditor/browser/outline/documentSymbolsTree.js

@@ -0,0 +1,281 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import './documentSymbolsTree.css.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { HighlightedLabel } from 'monaco-editor/esm/vs/base/browser/ui/highlightedlabel/highlightedLabel.js';
+import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { SymbolKinds } from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { OutlineModel, OutlineElement, OutlineGroup } from 'monaco-editor/esm/vs/editor/contrib/documentSymbols/browser/outlineModel.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IconLabel } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabel.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { MarkerSeverity } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { listErrorForeground, listWarningForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IdleValue } from 'monaco-editor/esm/vs/base/common/async.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+class DocumentSymbolNavigationLabelProvider {
+    getKeyboardNavigationLabel(element) {
+        if (element instanceof OutlineGroup) {
+            return element.label;
+        }
+        else {
+            return element.symbol.name;
+        }
+    }
+}
+class DocumentSymbolAccessibilityProvider {
+    constructor(_ariaLabel) {
+        this._ariaLabel = _ariaLabel;
+    }
+    getWidgetAriaLabel() {
+        return this._ariaLabel;
+    }
+    getAriaLabel(element) {
+        if (element instanceof OutlineGroup) {
+            return element.label;
+        }
+        else {
+            return element.symbol.name;
+        }
+    }
+}
+class DocumentSymbolIdentityProvider {
+    getId(element) {
+        return element.id;
+    }
+}
+class DocumentSymbolGroupTemplate {
+    constructor(labelContainer, label) {
+        this.labelContainer = labelContainer;
+        this.label = label;
+    }
+}
+DocumentSymbolGroupTemplate.id = 'DocumentSymbolGroupTemplate';
+class DocumentSymbolTemplate {
+    constructor(container, iconLabel, iconClass, decoration) {
+        this.container = container;
+        this.iconLabel = iconLabel;
+        this.iconClass = iconClass;
+        this.decoration = decoration;
+    }
+}
+DocumentSymbolTemplate.id = 'DocumentSymbolTemplate';
+class DocumentSymbolVirtualDelegate {
+    getHeight(_element) {
+        return 22;
+    }
+    getTemplateId(element) {
+        return element instanceof OutlineGroup
+            ? DocumentSymbolGroupTemplate.id
+            : DocumentSymbolTemplate.id;
+    }
+}
+class DocumentSymbolGroupRenderer {
+    constructor() {
+        this.templateId = DocumentSymbolGroupTemplate.id;
+    }
+    renderTemplate(container) {
+        const labelContainer = dom.$('.outline-element-label');
+        container.classList.add('outline-element');
+        dom.append(container, labelContainer);
+        return ( new DocumentSymbolGroupTemplate(labelContainer, ( new HighlightedLabel(labelContainer))));
+    }
+    renderElement(node, _index, template) {
+        template.label.set(node.element.label, createMatches(node.filterData));
+    }
+    disposeTemplate(_template) {
+    }
+}
+let DocumentSymbolRenderer = class DocumentSymbolRenderer {
+    constructor(_renderMarker, _configurationService, _themeService) {
+        this._renderMarker = _renderMarker;
+        this._configurationService = _configurationService;
+        this._themeService = _themeService;
+        this.templateId = DocumentSymbolTemplate.id;
+    }
+    renderTemplate(container) {
+        container.classList.add('outline-element');
+        const iconLabel = ( new IconLabel(container, { supportHighlights: true }));
+        const iconClass = dom.$('.outline-element-icon');
+        const decoration = dom.$('.outline-element-decoration');
+        container.prepend(iconClass);
+        container.appendChild(decoration);
+        return ( new DocumentSymbolTemplate(container, iconLabel, iconClass, decoration));
+    }
+    renderElement(node, _index, template) {
+        const { element } = node;
+        const extraClasses = ['nowrap'];
+        const options = {
+            matches: createMatches(node.filterData),
+            labelEscapeNewLines: true,
+            extraClasses,
+            title: ( localize(
+                'title.template',
+                "{0} ({1})",
+                element.symbol.name,
+                DocumentSymbolRenderer._symbolKindNames[element.symbol.kind]
+            ))
+        };
+        if (this._configurationService.getValue("outline.icons" )) {
+            template.iconClass.className = '';
+            template.iconClass.classList.add('outline-element-icon', 'inline', ...ThemeIcon.asClassNameArray(SymbolKinds.toIcon(element.symbol.kind)));
+        }
+        if (element.symbol.tags.indexOf(1 ) >= 0) {
+            extraClasses.push(`deprecated`);
+            options.matches = [];
+        }
+        template.iconLabel.setLabel(element.symbol.name, element.symbol.detail, options);
+        if (this._renderMarker) {
+            this._renderMarkerInfo(element, template);
+        }
+    }
+    _renderMarkerInfo(element, template) {
+        if (!element.marker) {
+            dom.hide(template.decoration);
+            template.container.style.removeProperty('--outline-element-color');
+            return;
+        }
+        const { count, topSev } = element.marker;
+        const color = this._themeService.getColorTheme().getColor(topSev === MarkerSeverity.Error ? listErrorForeground : listWarningForeground);
+        const cssColor = color ? ( color.toString()) : 'inherit';
+        if (this._configurationService.getValue("outline.problems.colors" )) {
+            template.container.style.setProperty('--outline-element-color', cssColor);
+        }
+        else {
+            template.container.style.removeProperty('--outline-element-color');
+        }
+        if (!this._configurationService.getValue("outline.problems.badges" )) {
+            dom.hide(template.decoration);
+        }
+        else if (count > 0) {
+            dom.show(template.decoration);
+            template.decoration.classList.remove('bubble');
+            template.decoration.innerText = count < 10 ? ( count.toString()) : '+9';
+            template.decoration.title = count === 1 ? ( localize('1.problem', "1 problem in this element")) : ( localize('N.problem', "{0} problems in this element", count));
+            template.decoration.style.setProperty('--outline-element-color', cssColor);
+        }
+        else {
+            dom.show(template.decoration);
+            template.decoration.classList.add('bubble');
+            template.decoration.innerText = '\uea71';
+            template.decoration.title = ( localize('deep.problem', "Contains elements with problems"));
+            template.decoration.style.setProperty('--outline-element-color', cssColor);
+        }
+    }
+    disposeTemplate(_template) {
+        _template.iconLabel.dispose();
+    }
+};
+DocumentSymbolRenderer._symbolKindNames = {
+    [17 ]: ( localize('Array', "array")),
+    [16 ]: ( localize('Boolean', "boolean")),
+    [4 ]: ( localize('Class', "class")),
+    [13 ]: ( localize('Constant', "constant")),
+    [8 ]: ( localize('Constructor', "constructor")),
+    [9 ]: ( localize('Enum', "enumeration")),
+    [21 ]: ( localize('EnumMember', "enumeration member")),
+    [23 ]: ( localize('Event', "event")),
+    [7 ]: ( localize('Field', "field")),
+    [0 ]: ( localize('File', "file")),
+    [11 ]: ( localize('Function', "function")),
+    [10 ]: ( localize('Interface', "interface")),
+    [19 ]: ( localize('Key', "key")),
+    [5 ]: ( localize('Method', "method")),
+    [1 ]: ( localize('Module', "module")),
+    [2 ]: ( localize('Namespace', "namespace")),
+    [20 ]: ( localize('Null', "null")),
+    [15 ]: ( localize('Number', "number")),
+    [18 ]: ( localize('Object', "object")),
+    [24 ]: ( localize('Operator', "operator")),
+    [3 ]: ( localize('Package', "package")),
+    [6 ]: ( localize('Property', "property")),
+    [14 ]: ( localize('String', "string")),
+    [22 ]: ( localize('Struct', "struct")),
+    [25 ]: ( localize('TypeParameter', "type parameter")),
+    [12 ]: ( localize('Variable', "variable")),
+};
+DocumentSymbolRenderer = ( __decorate([
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IThemeService))
+], DocumentSymbolRenderer));
+let DocumentSymbolFilter = class DocumentSymbolFilter {
+    constructor(_prefix, _textResourceConfigService) {
+        this._prefix = _prefix;
+        this._textResourceConfigService = _textResourceConfigService;
+    }
+    filter(element) {
+        const outline = OutlineModel.get(element);
+        if (!(element instanceof OutlineElement)) {
+            return true;
+        }
+        const configName = DocumentSymbolFilter.kindToConfigName[element.symbol.kind];
+        const configKey = `${this._prefix}.${configName}`;
+        return this._textResourceConfigService.getValue(outline?.uri, configKey);
+    }
+};
+DocumentSymbolFilter.kindToConfigName = ( Object.freeze({
+    [0 ]: 'showFiles',
+    [1 ]: 'showModules',
+    [2 ]: 'showNamespaces',
+    [3 ]: 'showPackages',
+    [4 ]: 'showClasses',
+    [5 ]: 'showMethods',
+    [6 ]: 'showProperties',
+    [7 ]: 'showFields',
+    [8 ]: 'showConstructors',
+    [9 ]: 'showEnums',
+    [10 ]: 'showInterfaces',
+    [11 ]: 'showFunctions',
+    [12 ]: 'showVariables',
+    [13 ]: 'showConstants',
+    [14 ]: 'showStrings',
+    [15 ]: 'showNumbers',
+    [16 ]: 'showBooleans',
+    [17 ]: 'showArrays',
+    [18 ]: 'showObjects',
+    [19 ]: 'showKeys',
+    [20 ]: 'showNull',
+    [21 ]: 'showEnumMembers',
+    [22 ]: 'showStructs',
+    [23 ]: 'showEvents',
+    [24 ]: 'showOperators',
+    [25 ]: 'showTypeParameters',
+}));
+DocumentSymbolFilter = ( __decorate([
+    ( __param(1, ITextResourceConfigurationService))
+], DocumentSymbolFilter));
+class DocumentSymbolComparator {
+    constructor() {
+        this._collator = ( new IdleValue(() => new Intl.Collator(undefined, { numeric: true })));
+    }
+    compareByPosition(a, b) {
+        if (a instanceof OutlineGroup && b instanceof OutlineGroup) {
+            return a.order - b.order;
+        }
+        else if (a instanceof OutlineElement && b instanceof OutlineElement) {
+            return Range.compareRangesUsingStarts(a.symbol.range, b.symbol.range) || this._collator.value.compare(a.symbol.name, b.symbol.name);
+        }
+        return 0;
+    }
+    compareByType(a, b) {
+        if (a instanceof OutlineGroup && b instanceof OutlineGroup) {
+            return a.order - b.order;
+        }
+        else if (a instanceof OutlineElement && b instanceof OutlineElement) {
+            return a.symbol.kind - b.symbol.kind || this._collator.value.compare(a.symbol.name, b.symbol.name);
+        }
+        return 0;
+    }
+    compareByName(a, b) {
+        if (a instanceof OutlineGroup && b instanceof OutlineGroup) {
+            return a.order - b.order;
+        }
+        else if (a instanceof OutlineElement && b instanceof OutlineElement) {
+            return this._collator.value.compare(a.symbol.name, b.symbol.name) || Range.compareRangesUsingStarts(a.symbol.range, b.symbol.range);
+        }
+        return 0;
+    }
+}
+export { DocumentSymbolAccessibilityProvider, DocumentSymbolComparator, DocumentSymbolFilter, DocumentSymbolGroupRenderer, DocumentSymbolIdentityProvider, DocumentSymbolNavigationLabelProvider, DocumentSymbolRenderer, DocumentSymbolVirtualDelegate };

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

@@ -0,0 +1,14 @@
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { EditorPaneDescriptor } from '../../../browser/editor.js';
+import { Extensions } from '../../../common/contributions.js';
+import { EditorExtensions } from '../../../common/editor.js';
+import { ComplexCustomWorkingCopyEditorHandler } from './customEditorInputFactory.js';
+import { WebviewEditor } from '../../webviewPanel/browser/webviewEditor.js';
+import { CustomEditorInput } from './customEditorInput.js';
+( Registry.as(EditorExtensions.EditorPane))
+    .registerEditorPane(EditorPaneDescriptor.create(WebviewEditor, WebviewEditor.ID, 'Webview Editor'), [
+    ( new SyncDescriptor(CustomEditorInput))
+]);
+( Registry.as(Extensions.Workbench))
+    .registerWorkbenchContribution(ComplexCustomWorkingCopyEditorHandler, 1 );

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

@@ -0,0 +1,143 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { CustomEditorInput } from './customEditorInput.js';
+import { ICustomEditorService } from '../common/customEditor.js';
+import { NotebookEditorInput } from '../../../../../../override/vs/workbench/contrib/notebook/common/notebookEditorInput.js';
+import { IWebviewService } from '../../webview/browser/webview.js';
+import { WebviewEditorInputSerializer, restoreWebviewOptions, restoreWebviewContentOptions, reviveWebviewExtensionDescription } from '../../webviewPanel/browser/webviewEditorInputSerializer.js';
+import { IWebviewWorkbenchService } from '../../webviewPanel/browser/webviewWorkbenchService.js';
+import { IWorkingCopyBackupService } from '../../../services/workingCopy/common/workingCopyBackup.js';
+import { IWorkingCopyEditorService } from '../../../services/workingCopy/common/workingCopyEditorService.js';
+let CustomEditorInputSerializer = class CustomEditorInputSerializer extends WebviewEditorInputSerializer {
+    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.ID = CustomEditorInput.typeId;
+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 {
+    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 };

package/dist/vscode/vs/workbench/contrib/customEditor/browser/customEditors.js

@@ -0,0 +1,212 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import './media/customEditor.css.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { extname, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { UndoCommand, RedoCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { EditorExtensions, DEFAULT_EDITOR_ASSOCIATION } from '../../../common/editor.js';
+import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
+import { CONTEXT_ACTIVE_CUSTOM_EDITOR_ID, CONTEXT_FOCUSED_CUSTOM_EDITOR_IS_EDITABLE, CustomEditorInfoCollection } from '../common/customEditor.js';
+import { CustomEditorModelManager } from '../common/customEditorModelManager.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { RegisteredEditorPriority, IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ContributedCustomEditors } from '../common/contributedCustomEditors.js';
+import { CustomEditorInput } from './customEditorInput.js';
+let CustomEditorService = class CustomEditorService extends Disposable {
+    constructor(contextKeyService, fileService, storageService, editorService, editorGroupService, instantiationService, uriIdentityService, editorResolverService) {
+        super();
+        this.editorService = editorService;
+        this.editorGroupService = editorGroupService;
+        this.instantiationService = instantiationService;
+        this.uriIdentityService = uriIdentityService;
+        this.editorResolverService = editorResolverService;
+        this._untitledCounter = 0;
+        this._editorResolverDisposables = this._register(( new DisposableStore()));
+        this._editorCapabilities = ( new Map());
+        this._models = ( new CustomEditorModelManager());
+        this._onDidChangeEditorTypes = this._register(( new Emitter()));
+        this.onDidChangeEditorTypes = this._onDidChangeEditorTypes.event;
+        this._fileEditorFactory = ( Registry.as(EditorExtensions.EditorFactory)).getFileEditorFactory();
+        this._activeCustomEditorId = CONTEXT_ACTIVE_CUSTOM_EDITOR_ID.bindTo(contextKeyService);
+        this._focusedCustomEditorIsEditable = CONTEXT_FOCUSED_CUSTOM_EDITOR_IS_EDITABLE.bindTo(contextKeyService);
+        this._contributedEditors = this._register(( new ContributedCustomEditors(storageService)));
+        this.editorResolverService.bufferChangeEvents(this.registerContributionPoints.bind(this));
+        this._register(this._contributedEditors.onChange(() => {
+            this.editorResolverService.bufferChangeEvents(this.registerContributionPoints.bind(this));
+            this.updateContexts();
+            this._onDidChangeEditorTypes.fire();
+        }));
+        this._register(this.editorService.onDidActiveEditorChange(() => this.updateContexts()));
+        this._register(fileService.onDidRunOperation(e => {
+            if (e.isOperation(2 )) {
+                this.handleMovedFileInOpenedFileEditors(e.resource, this.uriIdentityService.asCanonicalUri(e.target.resource));
+            }
+        }));
+        const PRIORITY = 105;
+        this._register(UndoCommand.addImplementation(PRIORITY, 'custom-editor', () => {
+            return this.withActiveCustomEditor(editor => editor.undo());
+        }));
+        this._register(RedoCommand.addImplementation(PRIORITY, 'custom-editor', () => {
+            return this.withActiveCustomEditor(editor => editor.redo());
+        }));
+        this.updateContexts();
+    }
+    getEditorTypes() {
+        return [...this._contributedEditors];
+    }
+    withActiveCustomEditor(f) {
+        const activeEditor = this.editorService.activeEditor;
+        if (activeEditor instanceof CustomEditorInput) {
+            const result = f(activeEditor);
+            if (result) {
+                return result;
+            }
+            return true;
+        }
+        return false;
+    }
+    registerContributionPoints() {
+        this._editorResolverDisposables.clear();
+        for (const contributedEditor of this._contributedEditors) {
+            for (const globPattern of contributedEditor.selector) {
+                if (!globPattern.filenamePattern) {
+                    continue;
+                }
+                this._editorResolverDisposables.add(this.editorResolverService.registerEditor(globPattern.filenamePattern, {
+                    id: contributedEditor.id,
+                    label: contributedEditor.displayName,
+                    detail: contributedEditor.providerDisplayName,
+                    priority: contributedEditor.priority,
+                }, {
+                    singlePerResource: () => !this.getCustomEditorCapabilities(contributedEditor.id)?.supportsMultipleEditorsPerDocument ?? true
+                }, {
+                    createEditorInput: ({ resource }, group) => {
+                        return { editor: CustomEditorInput.create(this.instantiationService, resource, contributedEditor.id, group.id) };
+                    },
+                    createUntitledEditorInput: ({ resource }, group) => {
+                        return { editor: CustomEditorInput.create(this.instantiationService, resource ?? ( URI.from(
+                            { scheme: Schemas.untitled, authority: `Untitled-${this._untitledCounter++}` }
+                        )), contributedEditor.id, group.id) };
+                    },
+                    createDiffEditorInput: (diffEditorInput, group) => {
+                        return { editor: this.createDiffEditorInput(diffEditorInput, contributedEditor.id, group) };
+                    },
+                }));
+            }
+        }
+    }
+    createDiffEditorInput(editor, editorID, group) {
+        const modifiedOverride = CustomEditorInput.create(this.instantiationService, assertIsDefined(editor.modified.resource), editorID, group.id, { customClasses: 'modified' });
+        const originalOverride = CustomEditorInput.create(this.instantiationService, assertIsDefined(editor.original.resource), editorID, group.id, { customClasses: 'original' });
+        return this.instantiationService.createInstance(DiffEditorInput, editor.label, editor.description, originalOverride, modifiedOverride, true);
+    }
+    get models() { return this._models; }
+    getCustomEditor(viewType) {
+        return this._contributedEditors.get(viewType);
+    }
+    getContributedCustomEditors(resource) {
+        return ( new CustomEditorInfoCollection(this._contributedEditors.getContributedEditors(resource)));
+    }
+    getUserConfiguredCustomEditors(resource) {
+        const resourceAssocations = this.editorResolverService.getAssociationsForResource(resource);
+        return ( new CustomEditorInfoCollection(coalesce(( resourceAssocations
+            .map(association => this._contributedEditors.get(association.viewType))))));
+    }
+    getAllCustomEditors(resource) {
+        return ( new CustomEditorInfoCollection([
+            ...this.getUserConfiguredCustomEditors(resource).allEditors,
+            ...this.getContributedCustomEditors(resource).allEditors,
+        ]));
+    }
+    registerCustomEditorCapabilities(viewType, options) {
+        if (( this._editorCapabilities.has(viewType))) {
+            throw new Error(`Capabilities for ${viewType} already set`);
+        }
+        this._editorCapabilities.set(viewType, options);
+        return toDisposable(() => {
+            this._editorCapabilities.delete(viewType);
+        });
+    }
+    getCustomEditorCapabilities(viewType) {
+        return this._editorCapabilities.get(viewType);
+    }
+    updateContexts() {
+        const activeEditorPane = this.editorService.activeEditorPane;
+        const resource = activeEditorPane?.input?.resource;
+        if (!resource) {
+            this._activeCustomEditorId.reset();
+            this._focusedCustomEditorIsEditable.reset();
+            return;
+        }
+        this._activeCustomEditorId.set(activeEditorPane?.input instanceof CustomEditorInput ? activeEditorPane.input.viewType : '');
+        this._focusedCustomEditorIsEditable.set(activeEditorPane?.input instanceof CustomEditorInput);
+    }
+    async handleMovedFileInOpenedFileEditors(oldResource, newResource) {
+        if (extname(oldResource).toLowerCase() === extname(newResource).toLowerCase()) {
+            return;
+        }
+        const possibleEditors = this.getAllCustomEditors(newResource);
+        if (!( possibleEditors.allEditors.some(editor => editor.priority !== RegisteredEditorPriority.option))) {
+            return;
+        }
+        const editorsToReplace = ( new Map());
+        for (const group of this.editorGroupService.groups) {
+            for (const editor of group.editors) {
+                if (this._fileEditorFactory.isFileEditor(editor)
+                    && !(editor instanceof CustomEditorInput)
+                    && isEqual(editor.resource, newResource)) {
+                    let entry = editorsToReplace.get(group.id);
+                    if (!entry) {
+                        entry = [];
+                        editorsToReplace.set(group.id, entry);
+                    }
+                    entry.push(editor);
+                }
+            }
+        }
+        if (!editorsToReplace.size) {
+            return;
+        }
+        for (const [group, entries] of editorsToReplace) {
+            this.editorService.replaceEditors(( entries.map(editor => {
+                let replacement;
+                if (possibleEditors.defaultEditor) {
+                    const viewType = possibleEditors.defaultEditor.id;
+                    replacement = CustomEditorInput.create(this.instantiationService, newResource, viewType, group);
+                }
+                else {
+                    replacement = { resource: newResource, options: { override: DEFAULT_EDITOR_ASSOCIATION.id } };
+                }
+                return {
+                    editor,
+                    replacement,
+                    options: {
+                        preserveFocus: true,
+                    }
+                };
+            })), group);
+        }
+    }
+};
+CustomEditorService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IEditorGroupsService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IUriIdentityService)),
+    ( __param(7, IEditorResolverService))
+], CustomEditorService));
+export { CustomEditorService };

package/dist/vscode/vs/workbench/contrib/customEditor/browser/media/customEditor.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".webview.modified{box-shadow:-6px 0 5px -5px var(--vscode-scrollbar-shadow)}";
+n(css,{});
+export { css, css as default };