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

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

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

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

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

package/dist/vscode/vs/workbench/contrib/customEditor/common/contributedCustomEditors.js

@@ -1,72 +0,0 @@
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { Memento } from '../../../common/memento.js';
-import { CustomEditorInfo } from './customEditor.js';
-import { customEditorsExtensionPoint } from './extensionPoint.js';
-import { RegisteredEditorPriority } from '../../../services/editor/common/editorResolverService.js';
-class ContributedCustomEditors extends Disposable {
-    constructor(storageService) {
-        super();
-        this._editors = ( new Map());
-        this._onChange = this._register(( new Emitter()));
-        this.onChange = this._onChange.event;
-        this._memento = ( new Memento(ContributedCustomEditors.CUSTOM_EDITORS_STORAGE_ID, storageService));
-        const mementoObject = this._memento.getMemento(0 , 1 );
-        for (const info of (mementoObject[ContributedCustomEditors.CUSTOM_EDITORS_ENTRY_ID] || [])) {
-            this.add(( new CustomEditorInfo(info)));
-        }
-        customEditorsExtensionPoint.setHandler(extensions => {
-            this.update(extensions);
-        });
-    }
-    update(extensions) {
-        this._editors.clear();
-        for (const extension of extensions) {
-            for (const webviewEditorContribution of extension.value) {
-                this.add(( new CustomEditorInfo({
-                    id: webviewEditorContribution.viewType,
-                    displayName: webviewEditorContribution.displayName,
-                    providerDisplayName: extension.description.isBuiltin ? ( nls.localize('builtinProviderDisplayName', "Built-in")) : extension.description.displayName || extension.description.identifier.value,
-                    selector: webviewEditorContribution.selector || [],
-                    priority: getPriorityFromContribution(webviewEditorContribution, extension.description),
-                })));
-            }
-        }
-        const mementoObject = this._memento.getMemento(0 , 1 );
-        mementoObject[ContributedCustomEditors.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( this._editors.values()));
-        this._memento.saveMemento();
-        this._onChange.fire();
-    }
-    [Symbol.iterator]() {
-        return ( this._editors.values());
-    }
-    get(viewType) {
-        return this._editors.get(viewType);
-    }
-    getContributedEditors(resource) {
-        return Array.from(( this._editors.values()))
-            .filter(customEditor => customEditor.matches(resource));
-    }
-    add(info) {
-        if (( this._editors.has(info.id))) {
-            console.error(`Custom editor with id '${info.id}' already registered`);
-            return;
-        }
-        this._editors.set(info.id, info);
-    }
-}
-ContributedCustomEditors.CUSTOM_EDITORS_STORAGE_ID = 'customEditors';
-ContributedCustomEditors.CUSTOM_EDITORS_ENTRY_ID = 'editors';
-function getPriorityFromContribution(contribution, extension) {
-    switch (contribution.priority) {
-        case RegisteredEditorPriority.default:
-        case RegisteredEditorPriority.option:
-            return contribution.priority;
-        case RegisteredEditorPriority.builtin:
-            return extension.isBuiltin ? RegisteredEditorPriority.builtin : RegisteredEditorPriority.default;
-        default:
-            return RegisteredEditorPriority.default;
-    }
-}
-export { ContributedCustomEditors };

package/dist/vscode/vs/workbench/contrib/customEditor/common/customEditorModelManager.js

@@ -1,61 +0,0 @@
-import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
-class CustomEditorModelManager {
-    constructor() {
-        this._references = ( (new Map()));
-    }
-    async getAllModels(resource) {
-        const keyStart = `${( ( resource.toString()))}@@@`;
-        const models = [];
-        for (const [key, entry] of this._references) {
-            if (key.startsWith(keyStart) && entry.model) {
-                models.push(await entry.model);
-            }
-        }
-        return models;
-    }
-    async get(resource, viewType) {
-        const key = this.key(resource, viewType);
-        const entry = this._references.get(key);
-        return entry?.model;
-    }
-    tryRetain(resource, viewType) {
-        const key = this.key(resource, viewType);
-        const entry = this._references.get(key);
-        if (!entry) {
-            return undefined;
-        }
-        entry.counter++;
-        return entry.model.then(model => {
-            return {
-                object: model,
-                dispose: once(() => {
-                    if (--entry.counter <= 0) {
-                        entry.model.then(x => x.dispose());
-                        this._references.delete(key);
-                    }
-                }),
-            };
-        });
-    }
-    add(resource, viewType, model) {
-        const key = this.key(resource, viewType);
-        const existing = this._references.get(key);
-        if (existing) {
-            throw new Error('Model already exists');
-        }
-        this._references.set(key, { viewType, model, counter: 0 });
-        return this.tryRetain(resource, viewType);
-    }
-    disposeAllModelsForView(viewType) {
-        for (const [key, value] of this._references) {
-            if (value.viewType === viewType) {
-                value.model.then(x => x.dispose());
-                this._references.delete(key);
-            }
-        }
-    }
-    key(resource, viewType) {
-        return `${( ( resource.toString()))}@@@${viewType}`;
-    }
-}
-export { CustomEditorModelManager };

package/dist/vscode/vs/workbench/contrib/customEditor/common/customTextEditorModel.js

@@ -1,70 +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 { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-let CustomTextEditorModel = class CustomTextEditorModel extends Disposable {
-    static async create(instantiationService, viewType, resource) {
-        return instantiationService.invokeFunction(async (accessor) => {
-            const textModelResolverService = accessor.get(ITextModelService);
-            const model = await textModelResolverService.createModelReference(resource);
-            return instantiationService.createInstance(CustomTextEditorModel, viewType, resource, model);
-        });
-    }
-    constructor(viewType, _resource, _model, textFileService) {
-        super();
-        this.viewType = viewType;
-        this._resource = _resource;
-        this._model = _model;
-        this.textFileService = textFileService;
-        this._onDidChangeOrphaned = this._register(( new Emitter()));
-        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
-        this._onDidChangeReadonly = this._register(( new Emitter()));
-        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
-        this._onDidChangeDirty = this._register(( new Emitter()));
-        this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeContent = this._register(( new Emitter()));
-        this.onDidChangeContent = this._onDidChangeContent.event;
-        this._register(_model);
-        this._textFileModel = this.textFileService.files.get(_resource);
-        if (this._textFileModel) {
-            this._register(this._textFileModel.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire()));
-            this._register(this._textFileModel.onDidChangeReadonly(() => this._onDidChangeReadonly.fire()));
-        }
-        this._register(this.textFileService.files.onDidChangeDirty(e => {
-            if (isEqual(this.resource, e.resource)) {
-                this._onDidChangeDirty.fire();
-                this._onDidChangeContent.fire();
-            }
-        }));
-    }
-    get resource() {
-        return this._resource;
-    }
-    isReadonly() {
-        return this._model.object.isReadonly();
-    }
-    get backupId() {
-        return undefined;
-    }
-    isDirty() {
-        return this.textFileService.isDirty(this.resource);
-    }
-    isOrphaned() {
-        return !!this._textFileModel?.hasState(4 );
-    }
-    async revert(options) {
-        return this.textFileService.revert(this.resource, options);
-    }
-    saveCustomEditor(options) {
-        return this.textFileService.save(this.resource, options);
-    }
-    async saveCustomEditorAs(resource, targetResource, options) {
-        return !!(await this.textFileService.saveAs(resource, targetResource, options));
-    }
-};
-CustomTextEditorModel = ( __decorate([
-    ( __param(3, ITextFileService))
-], CustomTextEditorModel));
-export { CustomTextEditorModel };

package/dist/vscode/vs/workbench/contrib/customEditor/common/extensionPoint.js

@@ -1,106 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
-import { languagesExtPoint } from '../../../services/language/common/languageService.js';
-const Fields = ( Object.freeze({
-    viewType: 'viewType',
-    displayName: 'displayName',
-    selector: 'selector',
-    priority: 'priority',
-}));
-const CustomEditorsContribution = {
-    description: ( nls.localize('contributes.customEditors', 'Contributed custom editors.')),
-    type: 'array',
-    defaultSnippets: [{
-            body: [{
-                    [Fields.viewType]: '$1',
-                    [Fields.displayName]: '$2',
-                    [Fields.selector]: [{
-                            filenamePattern: '$3'
-                        }],
-                }]
-        }],
-    items: {
-        type: 'object',
-        required: [
-            Fields.viewType,
-            Fields.displayName,
-            Fields.selector,
-        ],
-        properties: {
-            [Fields.viewType]: {
-                type: 'string',
-                markdownDescription: ( nls.localize(
-                    'contributes.viewType',
-                    'Identifier for the custom editor. This must be unique across all custom editors, so we recommend including your extension id as part of `viewType`. The `viewType` is used when registering custom editors with `vscode.registerCustomEditorProvider` and in the `onCustomEditor:${id}` [activation event](https://code.visualstudio.com/api/references/activation-events).'
-                )),
-            },
-            [Fields.displayName]: {
-                type: 'string',
-                description: ( nls.localize(
-                    'contributes.displayName',
-                    'Human readable name of the custom editor. This is displayed to users when selecting which editor to use.'
-                )),
-            },
-            [Fields.selector]: {
-                type: 'array',
-                description: ( nls.localize(
-                    'contributes.selector',
-                    'Set of globs that the custom editor is enabled for.'
-                )),
-                items: {
-                    type: 'object',
-                    defaultSnippets: [{
-                            body: {
-                                filenamePattern: '$1',
-                            }
-                        }],
-                    properties: {
-                        filenamePattern: {
-                            type: 'string',
-                            description: ( nls.localize(
-                                'contributes.selector.filenamePattern',
-                                'Glob that the custom editor is enabled for.'
-                            )),
-                        },
-                    }
-                }
-            },
-            [Fields.priority]: {
-                type: 'string',
-                markdownDeprecationMessage: ( nls.localize(
-                    'contributes.priority',
-                    'Controls if the custom editor is enabled automatically when the user opens a file. This may be overridden by users using the `workbench.editorAssociations` setting.'
-                )),
-                enum: [
-                    "default" ,
-                    "option" ,
-                ],
-                markdownEnumDescriptions: [
-                    ( nls.localize(
-                        'contributes.priority.default',
-                        'The editor is automatically used when the user opens a resource, provided that no other default custom editors are registered for that resource.'
-                    )),
-                    ( nls.localize(
-                        'contributes.priority.option',
-                        'The editor is not automatically used when the user opens a resource, but a user can switch to the editor using the `Reopen With` command.'
-                    )),
-                ],
-                default: 'default'
-            }
-        }
-    }
-};
-const customEditorsExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'customEditors',
-    deps: [languagesExtPoint],
-    jsonSchema: CustomEditorsContribution,
-    activationEventsGenerator: (contribs, result) => {
-        for (const contrib of contribs) {
-            const viewType = contrib[Fields.viewType];
-            if (viewType) {
-                result.push(`onCustomEditor:${viewType}`);
-            }
-        }
-    },
-}));
-export { customEditorsExtensionPoint };