@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/vscode/vs/workbench/contrib/debug/common/loadedScriptsPicker.js

@@ -0,0 +1,81 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IDebugService } from './debug.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { getIconClasses } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+async function showLoadedScriptMenu(accessor) {
+    const quickInputService = accessor.get(IQuickInputService);
+    const debugService = accessor.get(IDebugService);
+    const editorService = accessor.get(IEditorService);
+    const sessions = debugService.getModel().getSessions(false);
+    const modelService = accessor.get(IModelService);
+    const languageService = accessor.get(ILanguageService);
+    const labelService = accessor.get(ILabelService);
+    const localDisposableStore = ( new DisposableStore());
+    const quickPick = quickInputService.createQuickPick();
+    localDisposableStore.add(quickPick);
+    quickPick.matchOnLabel = quickPick.matchOnDescription = quickPick.matchOnDetail = quickPick.sortByLabel = false;
+    quickPick.placeholder = ( nls.localize('moveFocusedView.selectView', "Search loaded scripts by name"));
+    quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);
+    localDisposableStore.add(quickPick.onDidChangeValue(async () => {
+        quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);
+    }));
+    localDisposableStore.add(quickPick.onDidAccept(() => {
+        const selectedItem = quickPick.selectedItems[0];
+        selectedItem.accept();
+        quickPick.hide();
+        localDisposableStore.dispose();
+    }));
+    quickPick.show();
+}
+async function _getPicksFromSession(session, filter, editorService, modelService, languageService, labelService) {
+    const items = [];
+    items.push({ type: 'separator', label: session.name });
+    const sources = await session.getLoadedSources();
+    sources.forEach((element) => {
+        const pick = _createPick(element, filter, editorService, modelService, languageService, labelService);
+        if (pick) {
+            items.push(pick);
+        }
+    });
+    return items;
+}
+async function _getPicks(filter, sessions, editorService, modelService, languageService, labelService) {
+    const loadedScriptPicks = [];
+    const picks = await Promise.all(( sessions.map(
+        (session) => _getPicksFromSession(session, filter, editorService, modelService, languageService, labelService)
+    )));
+    for (const row of picks) {
+        for (const elem of row) {
+            loadedScriptPicks.push(elem);
+        }
+    }
+    return loadedScriptPicks;
+}
+function _createPick(source, filter, editorService, modelService, languageService, labelService) {
+    const label = labelService.getUriBasenameLabel(source.uri);
+    const desc = labelService.getUriLabel(dirname(source.uri));
+    const labelHighlights = matchesFuzzy(filter, label, true);
+    const descHighlights = matchesFuzzy(filter, desc, true);
+    if (labelHighlights || descHighlights) {
+        return {
+            label,
+            description: desc === '.' ? undefined : desc,
+            highlights: { label: labelHighlights ?? undefined, description: descHighlights ?? undefined },
+            iconClasses: getIconClasses(modelService, languageService, source.uri),
+            accept: () => {
+                if (source.available) {
+                    source.openInEditor(editorService, { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 });
+                }
+            }
+        };
+    }
+    return undefined;
+}
+export { showLoadedScriptMenu };

package/dist/vscode/vs/workbench/contrib/debug/common/replModel.js

@@ -0,0 +1,230 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ExpressionContainer } from './debugModel.js';
+const MAX_REPL_LENGTH = 10000;
+let topReplElementCounter = 0;
+const getUniqueId = () => `topReplElement:${topReplElementCounter++}`;
+class ReplOutputElement {
+    constructor(session, id, value, severity, sourceData, expression) {
+        this.session = session;
+        this.id = id;
+        this.value = value;
+        this.severity = severity;
+        this.sourceData = sourceData;
+        this.expression = expression;
+        this._count = 1;
+        this._onDidChangeCount = ( new Emitter());
+    }
+    toString(includeSource = false) {
+        let valueRespectCount = this.value;
+        for (let i = 1; i < this.count; i++) {
+            valueRespectCount += (valueRespectCount.endsWith('\n') ? '' : '\n') + this.value;
+        }
+        const sourceStr = (this.sourceData && includeSource) ? ` ${this.sourceData.source.name}` : '';
+        return valueRespectCount + sourceStr;
+    }
+    getId() {
+        return this.id;
+    }
+    getChildren() {
+        return this.expression?.getChildren() || Promise.resolve([]);
+    }
+    set count(value) {
+        this._count = value;
+        this._onDidChangeCount.fire();
+    }
+    get count() {
+        return this._count;
+    }
+    get onDidChangeCount() {
+        return this._onDidChangeCount.event;
+    }
+    get hasChildren() {
+        return !!this.expression?.hasChildren;
+    }
+}
+class ReplVariableElement {
+    constructor(expr, severity, sourceData) {
+        this.expr = expr;
+        this.severity = severity;
+        this.sourceData = sourceData;
+        this.id = generateUuid();
+        this.hasChildren = expr.hasChildren;
+    }
+    getChildren() {
+        return this.expr.getChildren();
+    }
+    toString() {
+        return ( this.expr.toString());
+    }
+    getId() {
+        return this.id;
+    }
+}
+class ReplEvaluationInput {
+    constructor(value) {
+        this.value = value;
+        this.id = generateUuid();
+    }
+    toString() {
+        return this.value;
+    }
+    getId() {
+        return this.id;
+    }
+}
+class ReplEvaluationResult extends ExpressionContainer {
+    get available() {
+        return this._available;
+    }
+    constructor() {
+        super(undefined, undefined, 0, generateUuid());
+        this._available = true;
+    }
+    async evaluateExpression(expression, session, stackFrame, context) {
+        const result = await super.evaluateExpression(expression, session, stackFrame, context);
+        this._available = result;
+        return result;
+    }
+    toString() {
+        return `${this.value}`;
+    }
+}
+class ReplGroup {
+    constructor(name, autoExpand, sourceData) {
+        this.name = name;
+        this.autoExpand = autoExpand;
+        this.sourceData = sourceData;
+        this.children = [];
+        this.ended = false;
+        this.id = `replGroup:${ReplGroup.COUNTER++}`;
+    }
+    get hasChildren() {
+        return true;
+    }
+    getId() {
+        return this.id;
+    }
+    toString(includeSource = false) {
+        const sourceStr = (includeSource && this.sourceData) ? ` ${this.sourceData.source.name}` : '';
+        return this.name + sourceStr;
+    }
+    addChild(child) {
+        const lastElement = this.children.length ? this.children[this.children.length - 1] : undefined;
+        if (lastElement instanceof ReplGroup && !lastElement.hasEnded) {
+            lastElement.addChild(child);
+        }
+        else {
+            this.children.push(child);
+        }
+    }
+    getChildren() {
+        return this.children;
+    }
+    end() {
+        const lastElement = this.children.length ? this.children[this.children.length - 1] : undefined;
+        if (lastElement instanceof ReplGroup && !lastElement.hasEnded) {
+            lastElement.end();
+        }
+        else {
+            this.ended = true;
+        }
+    }
+    get hasEnded() {
+        return this.ended;
+    }
+}
+ReplGroup.COUNTER = 0;
+function areSourcesEqual(first, second) {
+    if (!first && !second) {
+        return true;
+    }
+    if (first && second) {
+        return first.column === second.column && first.lineNumber === second.lineNumber && ( first.source.uri.toString()) === ( second.source.uri.toString());
+    }
+    return false;
+}
+class ReplModel {
+    constructor(configurationService) {
+        this.configurationService = configurationService;
+        this.replElements = [];
+        this._onDidChangeElements = ( new Emitter());
+        this.onDidChangeElements = this._onDidChangeElements.event;
+    }
+    getReplElements() {
+        return this.replElements;
+    }
+    async addReplExpression(session, stackFrame, name) {
+        this.addReplElement(( new ReplEvaluationInput(name)));
+        const result = ( new ReplEvaluationResult());
+        await result.evaluateExpression(name, session, stackFrame, 'repl');
+        this.addReplElement(result);
+    }
+    appendToRepl(session, { output, expression, sev, source }) {
+        const clearAnsiSequence = '\u001b[2J';
+        const clearAnsiIndex = output.lastIndexOf(clearAnsiSequence);
+        if (clearAnsiIndex !== -1) {
+            this.removeReplExpressions();
+            this.appendToRepl(session, { output: ( nls.localize('consoleCleared', "Console was cleared")), sev: Severity.Ignore });
+            output = output.substring(clearAnsiIndex + clearAnsiSequence.length);
+        }
+        if (expression) {
+            this.addReplElement(output
+                ? ( new ReplOutputElement(session, getUniqueId(), output, sev, source, expression))
+                : ( new ReplVariableElement(expression, sev, source)));
+            return;
+        }
+        const previousElement = this.replElements.length ? this.replElements[this.replElements.length - 1] : undefined;
+        if (previousElement instanceof ReplOutputElement && previousElement.severity === sev) {
+            const config = this.configurationService.getValue('debug');
+            if (previousElement.value === output && areSourcesEqual(previousElement.sourceData, source) && config.console.collapseIdenticalLines) {
+                previousElement.count++;
+                return;
+            }
+            if (!previousElement.value.endsWith('\n') && !previousElement.value.endsWith('\r\n') && previousElement.count === 1) {
+                this.replElements[this.replElements.length - 1] = ( new ReplOutputElement(session, getUniqueId(), previousElement.value + output, sev, source));
+                this._onDidChangeElements.fire();
+                return;
+            }
+        }
+        const element = ( new ReplOutputElement(session, getUniqueId(), output, sev, source));
+        this.addReplElement(element);
+    }
+    startGroup(name, autoExpand, sourceData) {
+        const group = ( new ReplGroup(name, autoExpand, sourceData));
+        this.addReplElement(group);
+    }
+    endGroup() {
+        const lastElement = this.replElements[this.replElements.length - 1];
+        if (lastElement instanceof ReplGroup) {
+            lastElement.end();
+        }
+    }
+    addReplElement(newElement) {
+        const lastElement = this.replElements.length ? this.replElements[this.replElements.length - 1] : undefined;
+        if (lastElement instanceof ReplGroup && !lastElement.hasEnded) {
+            lastElement.addChild(newElement);
+        }
+        else {
+            this.replElements.push(newElement);
+            if (this.replElements.length > MAX_REPL_LENGTH) {
+                this.replElements.splice(0, this.replElements.length - MAX_REPL_LENGTH);
+            }
+        }
+        this._onDidChangeElements.fire();
+    }
+    removeReplExpressions() {
+        if (this.replElements.length > 0) {
+            this.replElements = [];
+            this._onDidChangeElements.fire();
+        }
+    }
+    clone() {
+        const newRepl = ( new ReplModel(this.configurationService));
+        newRepl.replElements = this.replElements.slice();
+        return newRepl;
+    }
+}
+export { ReplEvaluationInput, ReplEvaluationResult, ReplGroup, ReplModel, ReplOutputElement, ReplVariableElement };

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

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IExtensionsWorkbenchService = ( createDecorator('extensionsWorkbenchService'));
+export { IExtensionsWorkbenchService };

package/dist/vscode/vs/workbench/contrib/files/browser/editors/fileEditorInput.js

@@ -0,0 +1,321 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import { DEFAULT_EDITOR_ASSOCIATION, findViewStateForEditor, isResourceEditorInput } from '../../../../common/editor.js';
+import { AbstractTextResourceEditorInput } from '../../../../common/editor/textResourceEditorInput.js';
+import { BinaryEditorModel } from '../../../../common/editor/binaryEditorModel.js';
+import { getLargeFileConfirmationLimit, ByteSize, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ITextFileService } from '../../../../services/textfile/common/textfiles.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { FILE_EDITOR_INPUT_ID, BINARY_FILE_EDITOR_ID, TEXT_FILE_EDITOR_ID } from '../../common/files.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IFilesConfigurationService } from '../../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { createTextBufferFactory } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { IPathService } from '../../../../services/path/common/pathService.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+let FileEditorInput = class FileEditorInput extends AbstractTextResourceEditorInput {
+    get typeId() {
+        return FILE_EDITOR_INPUT_ID;
+    }
+    get editorId() {
+        return DEFAULT_EDITOR_ASSOCIATION.id;
+    }
+    get capabilities() {
+        let capabilities = 32 ;
+        if (this.model) {
+            if (this.model.isReadonly()) {
+                capabilities |= 2 ;
+            }
+        }
+        else {
+            if (this.fileService.hasProvider(this.resource)) {
+                if (this.fileService.hasCapability(this.resource, 2048 )) {
+                    capabilities |= 2 ;
+                }
+            }
+            else {
+                capabilities |= 4 ;
+            }
+        }
+        if (!((capabilities & 2) )) {
+            capabilities |= 128 ;
+        }
+        return capabilities;
+    }
+    constructor(resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents, instantiationService, textFileService, textModelResolverService, labelService, fileService, filesConfigurationService, editorService, pathService, textResourceConfigurationService) {
+        super(resource, preferredResource, editorService, textFileService, labelService, fileService);
+        this.instantiationService = instantiationService;
+        this.textModelResolverService = textModelResolverService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.pathService = pathService;
+        this.textResourceConfigurationService = textResourceConfigurationService;
+        this.forceOpenAs = 0 ;
+        this.model = undefined;
+        this.cachedTextFileModelReference = undefined;
+        this.modelListeners = this._register(( new DisposableStore()));
+        this.model = this.textFileService.files.get(resource);
+        if (preferredName) {
+            this.setPreferredName(preferredName);
+        }
+        if (preferredDescription) {
+            this.setPreferredDescription(preferredDescription);
+        }
+        if (preferredEncoding) {
+            this.setPreferredEncoding(preferredEncoding);
+        }
+        if (preferredLanguageId) {
+            this.setPreferredLanguageId(preferredLanguageId);
+        }
+        if (typeof preferredContents === 'string') {
+            this.setPreferredContents(preferredContents);
+        }
+        this._register(this.textFileService.files.onDidCreate(model => this.onDidCreateTextFileModel(model)));
+        if (this.model) {
+            this.registerModelListeners(this.model);
+        }
+    }
+    onDidCreateTextFileModel(model) {
+        if (isEqual(model.resource, this.resource)) {
+            this.model = model;
+            this.registerModelListeners(model);
+        }
+    }
+    registerModelListeners(model) {
+        this.modelListeners.clear();
+        this.modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+        this.modelListeners.add(model.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire()));
+        this.modelListeners.add(model.onDidSaveError(() => this._onDidChangeDirty.fire()));
+        this.modelListeners.add(Event.once(model.onWillDispose)(() => {
+            this.modelListeners.clear();
+            this.model = undefined;
+        }));
+    }
+    getName() {
+        return this.preferredName || super.getName();
+    }
+    setPreferredName(name) {
+        if (!this.allowLabelOverride()) {
+            return;
+        }
+        if (this.preferredName !== name) {
+            this.preferredName = name;
+            this._onDidChangeLabel.fire();
+        }
+    }
+    allowLabelOverride() {
+        return this.resource.scheme !== this.pathService.defaultUriScheme &&
+            this.resource.scheme !== Schemas.vscodeUserData &&
+            this.resource.scheme !== Schemas.file &&
+            this.resource.scheme !== Schemas.vscodeRemote;
+    }
+    getPreferredName() {
+        return this.preferredName;
+    }
+    getDescription(verbosity) {
+        return this.preferredDescription || super.getDescription(verbosity);
+    }
+    setPreferredDescription(description) {
+        if (!this.allowLabelOverride()) {
+            return;
+        }
+        if (this.preferredDescription !== description) {
+            this.preferredDescription = description;
+            this._onDidChangeLabel.fire();
+        }
+    }
+    getPreferredDescription() {
+        return this.preferredDescription;
+    }
+    getEncoding() {
+        if (this.model) {
+            return this.model.getEncoding();
+        }
+        return this.preferredEncoding;
+    }
+    getPreferredEncoding() {
+        return this.preferredEncoding;
+    }
+    async setEncoding(encoding, mode) {
+        this.setPreferredEncoding(encoding);
+        return this.model?.setEncoding(encoding, mode);
+    }
+    setPreferredEncoding(encoding) {
+        this.preferredEncoding = encoding;
+        this.setForceOpenAsText();
+    }
+    getLanguageId() {
+        if (this.model) {
+            return this.model.getLanguageId();
+        }
+        return this.preferredLanguageId;
+    }
+    getPreferredLanguageId() {
+        return this.preferredLanguageId;
+    }
+    setLanguageId(languageId, source) {
+        this.setPreferredLanguageId(languageId);
+        this.model?.setLanguageId(languageId, source);
+    }
+    setPreferredLanguageId(languageId) {
+        this.preferredLanguageId = languageId;
+        this.setForceOpenAsText();
+    }
+    setPreferredContents(contents) {
+        this.preferredContents = contents;
+        this.setForceOpenAsText();
+    }
+    setForceOpenAsText() {
+        this.forceOpenAs = 1 ;
+    }
+    setForceOpenAsBinary() {
+        this.forceOpenAs = 2 ;
+    }
+    isDirty() {
+        return !!(this.model?.isDirty());
+    }
+    isSaving() {
+        if (this.model?.hasState(0 ) || this.model?.hasState(3 ) || this.model?.hasState(5 )) {
+            return false;
+        }
+        if (this.filesConfigurationService.getAutoSaveMode() === 1 ) {
+            return true;
+        }
+        return super.isSaving();
+    }
+    prefersEditorPane(editorPanes) {
+        if (this.forceOpenAs === 2 ) {
+            return editorPanes.find(editorPane => editorPane.typeId === BINARY_FILE_EDITOR_ID);
+        }
+        return editorPanes.find(editorPane => editorPane.typeId === TEXT_FILE_EDITOR_ID);
+    }
+    resolve(options) {
+        if (this.forceOpenAs === 2 ) {
+            return this.doResolveAsBinary();
+        }
+        return this.doResolveAsText(options);
+    }
+    async doResolveAsText(options) {
+        try {
+            const preferredContents = this.preferredContents;
+            this.preferredContents = undefined;
+            await this.textFileService.files.resolve(this.resource, {
+                languageId: this.preferredLanguageId,
+                encoding: this.preferredEncoding,
+                contents: typeof preferredContents === 'string' ? createTextBufferFactory(preferredContents) : undefined,
+                reload: { async: true },
+                allowBinary: this.forceOpenAs === 1 ,
+                reason: 1 ,
+                limits: this.ensureLimits(options)
+            });
+            if (!this.cachedTextFileModelReference) {
+                this.cachedTextFileModelReference = await this.textModelResolverService.createModelReference(this.resource);
+            }
+            const model = this.cachedTextFileModelReference.object;
+            if (this.isDisposed()) {
+                this.disposeModelReference();
+            }
+            return model;
+        }
+        catch (error) {
+            if (error.textFileOperationResult === 0 ) {
+                return this.doResolveAsBinary();
+            }
+            throw error;
+        }
+    }
+    ensureLimits(options) {
+        if (options?.limits) {
+            return options.limits;
+        }
+        const defaultSizeLimit = getLargeFileConfirmationLimit(this.resource);
+        let configuredSizeLimit = undefined;
+        const configuredSizeLimitMb = this.textResourceConfigurationService.getValue(this.resource, 'workbench.editorLargeFileConfirmation');
+        if (typeof configuredSizeLimitMb === 'number') {
+            configuredSizeLimit = configuredSizeLimitMb * ByteSize.MB;
+        }
+        return {
+            size: Math.max(defaultSizeLimit, configuredSizeLimit ?? defaultSizeLimit)
+        };
+    }
+    async doResolveAsBinary() {
+        const model = this.instantiationService.createInstance(BinaryEditorModel, this.preferredResource, this.getName());
+        await model.resolve();
+        return model;
+    }
+    isResolved() {
+        return !!this.model;
+    }
+    async rename(group, target) {
+        return {
+            editor: {
+                resource: target,
+                encoding: this.getEncoding(),
+                options: {
+                    viewState: findViewStateForEditor(this, group, this.editorService)
+                }
+            }
+        };
+    }
+    toUntyped(options) {
+        const untypedInput = {
+            resource: this.preferredResource,
+            forceFile: true,
+            options: {
+                override: this.editorId
+            }
+        };
+        if (typeof options?.preserveViewState === 'number') {
+            untypedInput.encoding = this.getEncoding();
+            untypedInput.languageId = this.getLanguageId();
+            untypedInput.contents = (() => {
+                const model = this.textFileService.files.get(this.resource);
+                if (model?.isDirty()) {
+                    return model.textEditorModel.getValue();
+                }
+                return undefined;
+            })();
+            untypedInput.options = {
+                ...untypedInput.options,
+                viewState: findViewStateForEditor(this, options.preserveViewState, this.editorService)
+            };
+        }
+        return untypedInput;
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (otherInput instanceof FileEditorInput) {
+            return isEqual(otherInput.resource, this.resource);
+        }
+        if (isResourceEditorInput(otherInput)) {
+            return super.matches(otherInput);
+        }
+        return false;
+    }
+    dispose() {
+        this.model = undefined;
+        this.disposeModelReference();
+        super.dispose();
+    }
+    disposeModelReference() {
+        dispose(this.cachedTextFileModelReference);
+        this.cachedTextFileModelReference = undefined;
+    }
+};
+FileEditorInput = ( __decorate([
+    ( __param(7, IInstantiationService)),
+    ( __param(8, ITextFileService)),
+    ( __param(9, ITextModelService)),
+    ( __param(10, ILabelService)),
+    ( __param(11, IFileService)),
+    ( __param(12, IFilesConfigurationService)),
+    ( __param(13, IEditorService)),
+    ( __param(14, IPathService)),
+    ( __param(15, ITextResourceConfigurationService))
+], FileEditorInput));
+export { FileEditorInput };