@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/workbench/common/contextkeys.js

@@ -0,0 +1,170 @@
+import { __decorate, __param } from '../../../../node_modules/tslib/tslib.es6.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { isEqual, basename, dirname, extname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+const IsFullscreenContext = ( new RawContextKey('isFullscreen', false, ( localize('isFullscreen', "Whether the window is in fullscreen mode"))));
+const ActiveEditorDirtyContext = ( new RawContextKey('activeEditorIsDirty', false, ( localize('activeEditorIsDirty', "Whether the active editor has unsaved changes"))));
+const ActiveEditorPinnedContext = ( new RawContextKey('activeEditorIsNotPreview', false, ( localize(
+    'activeEditorIsNotPreview',
+    "Whether the active editor is not in preview mode"
+))));
+const ActiveEditorLastInGroupContext = ( new RawContextKey('activeEditorIsLastInGroup', false, ( localize(
+    'activeEditorIsLastInGroup',
+    "Whether the active editor is the last one in its group"
+))));
+const ActiveEditorStickyContext = ( new RawContextKey('activeEditorIsPinned', false, ( localize('activeEditorIsPinned', "Whether the active editor is pinned"))));
+const ActiveEditorCanSplitInGroupContext = ( new RawContextKey('activeEditorCanSplitInGroup', true));
+const ActiveEditorAvailableEditorIdsContext = ( new RawContextKey('activeEditorAvailableEditorIds', '', ( localize(
+    'activeEditorAvailableEditorIds',
+    "The available editor identifiers that are usable for the active editor"
+))));
+const TextCompareEditorVisibleContext = ( new RawContextKey('textCompareEditorVisible', false, ( localize('textCompareEditorVisible', "Whether a text compare editor is visible"))));
+const TextCompareEditorActiveContext = ( new RawContextKey('textCompareEditorActive', false, ( localize('textCompareEditorActive', "Whether a text compare editor is active"))));
+const SideBySideEditorActiveContext = ( new RawContextKey('sideBySideEditorActive', false, ( localize('sideBySideEditorActive', "Whether a side by side editor is active"))));
+const EditorGroupEditorsCountContext = ( new RawContextKey('groupEditorsCount', 0, ( localize('groupEditorsCount', "The number of opened editor groups"))));
+const ActiveEditorGroupEmptyContext = ( new RawContextKey('activeEditorGroupEmpty', false, ( localize('activeEditorGroupEmpty', "Whether the active editor group is empty"))));
+const ActiveEditorGroupLockedContext = ( new RawContextKey('activeEditorGroupLocked', false, ( localize('activeEditorGroupLocked', "Whether the active editor group is locked"))));
+const MultipleEditorGroupsContext = ( new RawContextKey('multipleEditorGroups', false, ( localize('multipleEditorGroups', "Whether there are multiple editor groups opened"))));
+const InEditorZenModeContext = ( new RawContextKey('inZenMode', false, ( localize('inZenMode', "Whether Zen mode is enabled"))));
+const IsCenteredLayoutContext = ( new RawContextKey('isCenteredLayout', false, ( localize('isCenteredLayout', "Whether centered layout is enabled"))));
+const EditorAreaVisibleContext = ( new RawContextKey('editorAreaVisible', true, ( localize('editorAreaVisible', "Whether the editor area is visible"))));
+const EditorTabsVisibleContext = ( new RawContextKey('editorTabsVisible', true, ( localize('editorTabsVisible', "Whether editor tabs are visible"))));
+const SideBarVisibleContext = ( new RawContextKey('sideBarVisible', false, ( localize('sideBarVisible', "Whether the sidebar is visible"))));
+const NotificationFocusedContext = ( new RawContextKey('notificationFocus', true, ( localize('notificationFocus', "Whether a notification has keyboard focus"))));
+const NotificationsCenterVisibleContext = ( new RawContextKey('notificationCenterVisible', false, ( localize('notificationCenterVisible', "Whether the notifications center is visible"))));
+const NotificationsToastsVisibleContext = ( new RawContextKey('notificationToastsVisible', false, ( localize('notificationToastsVisible', "Whether a notification toast is visible"))));
+const AuxiliaryBarVisibleContext = ( new RawContextKey('auxiliaryBarVisible', false, ( localize('auxiliaryBarVisible', "Whether the auxiliary bar is visible"))));
+const PanelFocusContext = ( new RawContextKey('panelFocus', false, ( localize('panelFocus', "Whether the panel has keyboard focus"))));
+const PanelPositionContext = ( new RawContextKey('panelPosition', 'bottom', ( localize('panelPosition', "The position of the panel, always 'bottom'"))));
+const PanelAlignmentContext = ( new RawContextKey('panelAlignment', 'center', ( localize(
+    'panelAlignment',
+    "The alignment of the panel, either 'center', 'left', 'right' or 'justify'"
+))));
+const PanelVisibleContext = ( new RawContextKey('panelVisible', false, ( localize('panelVisible', "Whether the panel is visible"))));
+const PanelMaximizedContext = ( new RawContextKey('panelMaximized', false, ( localize('panelMaximized', "Whether the panel is maximized"))));
+const FocusedViewContext = ( new RawContextKey('focusedView', '', ( localize('focusedView', "The identifier of the view that has keyboard focus"))));
+let ResourceContextKey = class ResourceContextKey {
+    constructor(_contextKeyService, _fileService, _languageService, _modelService) {
+        this._contextKeyService = _contextKeyService;
+        this._fileService = _fileService;
+        this._languageService = _languageService;
+        this._modelService = _modelService;
+        this._disposables = ( new DisposableStore());
+        this._schemeKey = ResourceContextKey.Scheme.bindTo(this._contextKeyService);
+        this._filenameKey = ResourceContextKey.Filename.bindTo(this._contextKeyService);
+        this._dirnameKey = ResourceContextKey.Dirname.bindTo(this._contextKeyService);
+        this._pathKey = ResourceContextKey.Path.bindTo(this._contextKeyService);
+        this._langIdKey = ResourceContextKey.LangId.bindTo(this._contextKeyService);
+        this._resourceKey = ResourceContextKey.Resource.bindTo(this._contextKeyService);
+        this._extensionKey = ResourceContextKey.Extension.bindTo(this._contextKeyService);
+        this._hasResource = ResourceContextKey.HasResource.bindTo(this._contextKeyService);
+        this._isFileSystemResource = ResourceContextKey.IsFileSystemResource.bindTo(this._contextKeyService);
+        this._disposables.add(_fileService.onDidChangeFileSystemProviderRegistrations(() => {
+            const resource = this.get();
+            this._isFileSystemResource.set(Boolean(resource && _fileService.hasProvider(resource)));
+        }));
+        this._disposables.add(_modelService.onModelAdded(model => {
+            if (isEqual(model.uri, this.get())) {
+                this._setLangId();
+            }
+        }));
+        this._disposables.add(_modelService.onModelLanguageChanged(e => {
+            if (isEqual(e.model.uri, this.get())) {
+                this._setLangId();
+            }
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    _setLangId() {
+        const value = this.get();
+        if (!value) {
+            this._langIdKey.set(null);
+            return;
+        }
+        const langId = this._modelService.getModel(value)?.getLanguageId() ?? this._languageService.guessLanguageIdByFilepathOrFirstLine(value);
+        this._langIdKey.set(langId);
+    }
+    set(value) {
+        value = value ?? undefined;
+        if (isEqual(this._value, value)) {
+            return;
+        }
+        this._value = value;
+        this._contextKeyService.bufferChangeEvents(() => {
+            this._resourceKey.set(value ? ( value.toString()) : null);
+            this._schemeKey.set(value ? value.scheme : null);
+            this._filenameKey.set(value ? basename(value) : null);
+            this._dirnameKey.set(value ? this.uriToPath(dirname(value)) : null);
+            this._pathKey.set(value ? this.uriToPath(value) : null);
+            this._setLangId();
+            this._extensionKey.set(value ? extname(value) : null);
+            this._hasResource.set(Boolean(value));
+            this._isFileSystemResource.set(value ? this._fileService.hasProvider(value) : false);
+        });
+    }
+    uriToPath(uri) {
+        if (uri.scheme === Schemas.file) {
+            return uri.fsPath;
+        }
+        return uri.path;
+    }
+    reset() {
+        this._value = undefined;
+        this._contextKeyService.bufferChangeEvents(() => {
+            this._resourceKey.reset();
+            this._schemeKey.reset();
+            this._filenameKey.reset();
+            this._dirnameKey.reset();
+            this._pathKey.reset();
+            this._langIdKey.reset();
+            this._extensionKey.reset();
+            this._hasResource.reset();
+            this._isFileSystemResource.reset();
+        });
+    }
+    get() {
+        return this._value;
+    }
+};
+ResourceContextKey.Scheme = ( new RawContextKey('resourceScheme', undefined, { type: 'string', description: ( localize('resourceScheme', "The scheme of the resource")) }));
+ResourceContextKey.Filename = ( new RawContextKey(
+    'resourceFilename',
+    undefined,
+    { type: 'string', description: ( localize('resourceFilename', "The file name of the resource")) }
+));
+ResourceContextKey.Dirname = ( new RawContextKey(
+    'resourceDirname',
+    undefined,
+    { type: 'string', description: ( localize('resourceDirname', "The folder name the resource is contained in")) }
+));
+ResourceContextKey.Path = ( new RawContextKey('resourcePath', undefined, { type: 'string', description: ( localize('resourcePath', "The full path of the resource")) }));
+ResourceContextKey.LangId = ( new RawContextKey('resourceLangId', undefined, { type: 'string', description: ( localize('resourceLangId', "The language identifier of the resource")) }));
+ResourceContextKey.Resource = ( new RawContextKey('resource', undefined, { type: 'URI', description: ( localize('resource', "The full value of the resource including scheme and path")) }));
+ResourceContextKey.Extension = ( new RawContextKey(
+    'resourceExtname',
+    undefined,
+    { type: 'string', description: ( localize('resourceExtname', "The extension name of the resource")) }
+));
+ResourceContextKey.HasResource = ( new RawContextKey('resourceSet', undefined, { type: 'boolean', description: ( localize('resourceSet', "Whether a resource is present or not")) }));
+ResourceContextKey.IsFileSystemResource = ( new RawContextKey(
+    'isFileSystemResource',
+    undefined,
+    { type: 'boolean', description: ( localize(
+        'isFileSystemResource',
+        "Whether the resource is backed by a file system provider"
+    )) }
+));
+ResourceContextKey = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IFileService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, IModelService))
+], ResourceContextKey));
+export { ActiveEditorAvailableEditorIdsContext, ActiveEditorCanSplitInGroupContext, ActiveEditorDirtyContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorStickyContext, AuxiliaryBarVisibleContext, EditorAreaVisibleContext, EditorGroupEditorsCountContext, EditorTabsVisibleContext, FocusedViewContext, InEditorZenModeContext, IsCenteredLayoutContext, IsFullscreenContext, MultipleEditorGroupsContext, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, PanelAlignmentContext, PanelFocusContext, PanelMaximizedContext, PanelPositionContext, PanelVisibleContext, ResourceContextKey, SideBarVisibleContext, SideBySideEditorActiveContext, TextCompareEditorActiveContext, TextCompareEditorVisibleContext };

package/dist/vscode/vs/workbench/common/contributions.js

@@ -0,0 +1,111 @@
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILifecycleService } from '../services/lifecycle/common/lifecycle.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { DeferredPromise, runWhenIdle } from 'monaco-editor/esm/vs/base/common/async.js';
+import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+var Extensions;
+( (function(Extensions) {
+    Extensions.Workbench = 'workbench.contributions.kind';
+})(Extensions || (Extensions = {})));
+class WorkbenchContributionsRegistry {
+    constructor() {
+        this.contributions = ( new Map());
+        this.pendingRestoredContributions = ( new DeferredPromise());
+    }
+    registerWorkbenchContribution(contribution, phase = 1 ) {
+        if (this.instantiationService && this.lifecycleService && this.logService && this.environmentService && this.lifecycleService.phase >= phase) {
+            this.safeCreateContribution(this.instantiationService, this.logService, this.environmentService, contribution, phase);
+        }
+        else {
+            let contributions = this.contributions.get(phase);
+            if (!contributions) {
+                contributions = [];
+                this.contributions.set(phase, contributions);
+            }
+            contributions.push(contribution);
+        }
+    }
+    start(accessor) {
+        const instantiationService = this.instantiationService = accessor.get(IInstantiationService);
+        const lifecycleService = this.lifecycleService = accessor.get(ILifecycleService);
+        const logService = this.logService = accessor.get(ILogService);
+        const environmentService = this.environmentService = accessor.get(IEnvironmentService);
+        for (const phase of [1 , 2 , 3 , 4 ]) {
+            this.instantiateByPhase(instantiationService, lifecycleService, logService, environmentService, phase);
+        }
+    }
+    instantiateByPhase(instantiationService, lifecycleService, logService, environmentService, phase) {
+        if (lifecycleService.phase >= phase) {
+            this.doInstantiateByPhase(instantiationService, logService, environmentService, phase);
+        }
+        else {
+            lifecycleService.when(phase).then(() => this.doInstantiateByPhase(instantiationService, logService, environmentService, phase));
+        }
+    }
+    async doInstantiateByPhase(instantiationService, logService, environmentService, phase) {
+        const contributions = this.contributions.get(phase);
+        if (contributions) {
+            this.contributions.delete(phase);
+            switch (phase) {
+                case 1 :
+                case 2 : {
+                    mark(`code/willCreateWorkbenchContributions/${phase}`);
+                    for (const contribution of contributions) {
+                        this.safeCreateContribution(instantiationService, logService, environmentService, contribution, phase);
+                    }
+                    mark(`code/didCreateWorkbenchContributions/${phase}`);
+                    break;
+                }
+                case 3 :
+                case 4 : {
+                    if (phase === 4 ) {
+                        await this.pendingRestoredContributions.p;
+                    }
+                    this.doInstantiateWhenIdle(contributions, instantiationService, logService, environmentService, phase);
+                    break;
+                }
+            }
+        }
+    }
+    doInstantiateWhenIdle(contributions, instantiationService, logService, environmentService, phase) {
+        mark(`code/willCreateWorkbenchContributions/${phase}`);
+        let i = 0;
+        const forcedTimeout = phase === 4  ? 3000 : 500;
+        const instantiateSome = (idle) => {
+            while (i < contributions.length) {
+                const contribution = contributions[i++];
+                this.safeCreateContribution(instantiationService, logService, environmentService, contribution, phase);
+                if (idle.timeRemaining() < 1) {
+                    runWhenIdle(instantiateSome, forcedTimeout);
+                    break;
+                }
+            }
+            if (i === contributions.length) {
+                mark(`code/didCreateWorkbenchContributions/${phase}`);
+                if (phase === 3 ) {
+                    this.pendingRestoredContributions.complete();
+                }
+            }
+        };
+        runWhenIdle(instantiateSome, forcedTimeout);
+    }
+    safeCreateContribution(instantiationService, logService, environmentService, contribution, phase) {
+        const now = phase < 3  ? Date.now() : undefined;
+        try {
+            instantiationService.createInstance(contribution);
+        }
+        catch (error) {
+            logService.error(`Unable to create workbench contribution ${contribution.name}.`, error);
+        }
+        if (typeof now === 'number' && !environmentService.isBuilt ) {
+            const time = Date.now() - now;
+            if (time > 20) {
+                logService.warn(`Workbench contribution ${contribution.name} blocked restore phase by ${time}ms.`);
+            }
+        }
+    }
+}
+Registry.add(Extensions.Workbench, ( new WorkbenchContributionsRegistry()));
+export { Extensions };

package/dist/vscode/vs/workbench/common/dialogs.js

@@ -0,0 +1,31 @@
+import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class DialogsModel extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.dialogs = [];
+        this._onWillShowDialog = this._register(( new Emitter()));
+        this.onWillShowDialog = this._onWillShowDialog.event;
+        this._onDidShowDialog = this._register(( new Emitter()));
+        this.onDidShowDialog = this._onDidShowDialog.event;
+    }
+    show(dialog) {
+        const promise = ( new DeferredPromise());
+        const item = {
+            args: dialog,
+            close: result => {
+                this.dialogs.splice(0, 1);
+                promise.complete(result);
+                this._onDidShowDialog.fire();
+            }
+        };
+        this.dialogs.push(item);
+        this._onWillShowDialog.fire();
+        return {
+            item,
+            result: promise.p
+        };
+    }
+}
+export { DialogsModel };

package/dist/vscode/vs/workbench/common/editor/binaryEditorModel.js

@@ -0,0 +1,39 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { EditorModel } from './editorModel.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { Mimes } from 'monaco-editor/esm/vs/base/common/mime.js';
+let BinaryEditorModel = class BinaryEditorModel extends EditorModel {
+    constructor(resource, name, fileService) {
+        super();
+        this.resource = resource;
+        this.name = name;
+        this.fileService = fileService;
+        this.mime = Mimes.binary;
+    }
+    getName() {
+        return this.name;
+    }
+    getSize() {
+        return this.size;
+    }
+    getMime() {
+        return this.mime;
+    }
+    getETag() {
+        return this.etag;
+    }
+    async resolve() {
+        if (this.fileService.hasProvider(this.resource)) {
+            const stat = await this.fileService.stat(this.resource);
+            this.etag = stat.etag;
+            if (typeof stat.size === 'number') {
+                this.size = stat.size;
+            }
+        }
+        return super.resolve();
+    }
+};
+BinaryEditorModel = ( __decorate([
+    ( __param(2, IFileService))
+], BinaryEditorModel));
+export { BinaryEditorModel };

package/dist/vscode/vs/workbench/common/editor/diffEditorInput.js

@@ -0,0 +1,164 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { SideBySideEditorInput } from './sideBySideEditorInput.js';
+import { BINARY_DIFF_EDITOR_ID, TEXT_DIFF_EDITOR_ID, isResourceDiffEditorInput } from '../editor.js';
+import { BaseTextEditorModel } from './textEditorModel.js';
+import { DiffEditorModel } from './diffEditorModel.js';
+import { TextDiffEditorModel } from './textDiffEditorModel.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IEditorService } from '../../services/editor/common/editorService.js';
+import { shorten } from 'monaco-editor/esm/vs/base/common/labels.js';
+let DiffEditorInput = class DiffEditorInput extends SideBySideEditorInput {
+    get typeId() {
+        return DiffEditorInput.ID;
+    }
+    get editorId() {
+        return this.modified.editorId === this.original.editorId ? this.modified.editorId : undefined;
+    }
+    get capabilities() {
+        let capabilities = super.capabilities;
+        if (this.labels.forceDescription) {
+            capabilities |= 64 ;
+        }
+        return capabilities;
+    }
+    constructor(preferredName, preferredDescription, original, modified, forceOpenAsBinary, editorService) {
+        super(preferredName, preferredDescription, original, modified, editorService);
+        this.original = original;
+        this.modified = modified;
+        this.forceOpenAsBinary = forceOpenAsBinary;
+        this.cachedModel = undefined;
+        this.labels = this.computeLabels();
+    }
+    computeLabels() {
+        let name;
+        let forceDescription = false;
+        if (this.preferredName) {
+            name = this.preferredName;
+        }
+        else {
+            const originalName = this.original.getName();
+            const modifiedName = this.modified.getName();
+            name = ( localize('sideBySideLabels', "{0} ↔ {1}", originalName, modifiedName));
+            forceDescription = originalName === modifiedName;
+        }
+        let shortDescription;
+        let mediumDescription;
+        let longDescription;
+        if (this.preferredDescription) {
+            shortDescription = this.preferredDescription;
+            mediumDescription = this.preferredDescription;
+            longDescription = this.preferredDescription;
+        }
+        else {
+            shortDescription = this.computeLabel(this.original.getDescription(0 ), this.modified.getDescription(0 ));
+            longDescription = this.computeLabel(this.original.getDescription(2 ), this.modified.getDescription(2 ));
+            const originalMediumDescription = this.original.getDescription(1 );
+            const modifiedMediumDescription = this.modified.getDescription(1 );
+            if ((typeof originalMediumDescription === 'string' && typeof modifiedMediumDescription === 'string') &&
+                (originalMediumDescription || modifiedMediumDescription)
+            ) {
+                const [shortenedOriginalMediumDescription, shortenedModifiedMediumDescription] = shorten([originalMediumDescription, modifiedMediumDescription]);
+                mediumDescription = this.computeLabel(shortenedOriginalMediumDescription, shortenedModifiedMediumDescription);
+            }
+        }
+        const shortTitle = this.computeLabel(this.original.getTitle(0 ) ?? this.original.getName(), this.modified.getTitle(0 ) ?? this.modified.getName(), ' ↔ ');
+        const mediumTitle = this.computeLabel(this.original.getTitle(1 ) ?? this.original.getName(), this.modified.getTitle(1 ) ?? this.modified.getName(), ' ↔ ');
+        const longTitle = this.computeLabel(this.original.getTitle(2 ) ?? this.original.getName(), this.modified.getTitle(2 ) ?? this.modified.getName(), ' ↔ ');
+        return { name, shortDescription, mediumDescription, longDescription, forceDescription, shortTitle, mediumTitle, longTitle };
+    }
+    computeLabel(originalLabel, modifiedLabel, separator = ' - ') {
+        if (!originalLabel || !modifiedLabel) {
+            return undefined;
+        }
+        if (originalLabel === modifiedLabel) {
+            return modifiedLabel;
+        }
+        return `${originalLabel}${separator}${modifiedLabel}`;
+    }
+    getName() {
+        return this.labels.name;
+    }
+    getDescription(verbosity = 1 ) {
+        switch (verbosity) {
+            case 0 :
+                return this.labels.shortDescription;
+            case 2 :
+                return this.labels.longDescription;
+            case 1 :
+            default:
+                return this.labels.mediumDescription;
+        }
+    }
+    getTitle(verbosity) {
+        switch (verbosity) {
+            case 0 :
+                return this.labels.shortTitle;
+            case 2 :
+                return this.labels.longTitle;
+            default:
+            case 1 :
+                return this.labels.mediumTitle;
+        }
+    }
+    async resolve(options) {
+        const resolvedModel = await this.createModel(options);
+        this.cachedModel?.dispose();
+        this.cachedModel = resolvedModel;
+        return this.cachedModel;
+    }
+    prefersEditorPane(editorPanes) {
+        if (this.forceOpenAsBinary) {
+            return editorPanes.find(editorPane => editorPane.typeId === BINARY_DIFF_EDITOR_ID);
+        }
+        return editorPanes.find(editorPane => editorPane.typeId === TEXT_DIFF_EDITOR_ID);
+    }
+    async createModel(options) {
+        const [originalEditorModel, modifiedEditorModel] = await Promise.all([
+            this.original.resolve(options),
+            this.modified.resolve(options)
+        ]);
+        if (modifiedEditorModel instanceof BaseTextEditorModel && originalEditorModel instanceof BaseTextEditorModel) {
+            return ( new TextDiffEditorModel(originalEditorModel, modifiedEditorModel));
+        }
+        return ( new DiffEditorModel(
+            withNullAsUndefined(originalEditorModel),
+            withNullAsUndefined(modifiedEditorModel)
+        ));
+    }
+    toUntyped(options) {
+        const untyped = super.toUntyped(options);
+        if (untyped) {
+            return {
+                ...untyped,
+                modified: untyped.primary,
+                original: untyped.secondary
+            };
+        }
+        return undefined;
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (otherInput instanceof DiffEditorInput) {
+            return this.modified.matches(otherInput.modified) && this.original.matches(otherInput.original) && otherInput.forceOpenAsBinary === this.forceOpenAsBinary;
+        }
+        if (isResourceDiffEditorInput(otherInput)) {
+            return this.modified.matches(otherInput.modified) && this.original.matches(otherInput.original);
+        }
+        return false;
+    }
+    dispose() {
+        if (this.cachedModel) {
+            this.cachedModel.dispose();
+            this.cachedModel = undefined;
+        }
+        super.dispose();
+    }
+};
+DiffEditorInput.ID = 'workbench.editors.diffEditorInput';
+DiffEditorInput = ( __decorate([
+    ( __param(5, IEditorService))
+], DiffEditorInput));
+export { DiffEditorInput };

package/dist/vscode/vs/workbench/common/editor/diffEditorModel.js

@@ -0,0 +1,23 @@
+import { EditorModel } from './editorModel.js';
+class DiffEditorModel extends EditorModel {
+    get originalModel() { return this._originalModel; }
+    get modifiedModel() { return this._modifiedModel; }
+    constructor(originalModel, modifiedModel) {
+        super();
+        this._originalModel = originalModel;
+        this._modifiedModel = modifiedModel;
+    }
+    async resolve() {
+        await Promise.all([
+            this._originalModel?.resolve(),
+            this._modifiedModel?.resolve()
+        ]);
+    }
+    isResolved() {
+        return !!(this.originalModel?.isResolved() && this.modifiedModel?.isResolved());
+    }
+    dispose() {
+        super.dispose();
+    }
+}
+export { DiffEditorModel };

package/dist/vscode/vs/workbench/common/editor/editorInput.js

@@ -0,0 +1,97 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { firstOrDefault } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { AbstractEditorInput, isEditorInput, EditorResourceAccessor } from '../editor.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+class EditorInput extends AbstractEditorInput {
+    constructor() {
+        super(...arguments);
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this._onDidChangeLabel = this._register(( new Emitter()));
+        this._onDidChangeCapabilities = this._register(( new Emitter()));
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this.onDidChangeLabel = this._onDidChangeLabel.event;
+        this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
+        this.onWillDispose = this._onWillDispose.event;
+        this.disposed = false;
+    }
+    get editorId() {
+        return undefined;
+    }
+    get capabilities() {
+        return 2 ;
+    }
+    hasCapability(capability) {
+        if (capability === 0 ) {
+            return this.capabilities === 0 ;
+        }
+        return (this.capabilities & capability) !== 0;
+    }
+    getName() {
+        return `Editor ${this.typeId}`;
+    }
+    getDescription(verbosity) {
+        return undefined;
+    }
+    getTitle(verbosity) {
+        return this.getName();
+    }
+    getLabelExtraClasses() {
+        return [];
+    }
+    getAriaLabel() {
+        return this.getTitle(0 );
+    }
+    getTelemetryDescriptor() {
+        return { typeId: this.typeId };
+    }
+    isDirty() {
+        return false;
+    }
+    isSaving() {
+        return false;
+    }
+    async resolve(options) {
+        return null;
+    }
+    async save(group, options) {
+        return this;
+    }
+    async saveAs(group, options) {
+        return this;
+    }
+    async revert(group, options) { }
+    async rename(group, target) {
+        return undefined;
+    }
+    copy() {
+        return this;
+    }
+    matches(otherInput) {
+        if (isEditorInput(otherInput)) {
+            return this === otherInput;
+        }
+        const otherInputEditorId = otherInput.options?.override;
+        if (this.editorId !== otherInputEditorId && otherInputEditorId !== undefined && this.editorId !== undefined) {
+            return false;
+        }
+        return isEqual(this.resource, EditorResourceAccessor.getCanonicalUri(otherInput));
+    }
+    prefersEditorPane(editorPanes) {
+        return firstOrDefault(editorPanes);
+    }
+    toUntyped(options) {
+        return undefined;
+    }
+    isDisposed() {
+        return this.disposed;
+    }
+    dispose() {
+        if (!this.disposed) {
+            this.disposed = true;
+            this._onWillDispose.fire();
+        }
+        super.dispose();
+    }
+}
+export { EditorInput };

package/dist/vscode/vs/workbench/common/editor/editorModel.js

@@ -0,0 +1,26 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class EditorModel extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+        this.disposed = false;
+        this.resolved = false;
+    }
+    async resolve() {
+        this.resolved = true;
+    }
+    isResolved() {
+        return this.resolved;
+    }
+    isDisposed() {
+        return this.disposed;
+    }
+    dispose() {
+        this.disposed = true;
+        this._onWillDispose.fire();
+        super.dispose();
+    }
+}
+export { EditorModel };