@codingame/monaco-vscode-api 19.1.4 → 20.0.0

package/vscode/src/vs/workbench/common/editor/sideBySideEditorInput.js

@@ -0,0 +1,303 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../../base/common/event.js';
+import { localize } from '../../../nls.js';
+import { Registry } from '../../../platform/registry/common/platform.js';
+import { EditorInputCapabilities, isResourceDiffEditorInput, isResourceMultiDiffEditorInput, isResourceSideBySideEditorInput, isResourceMergeEditorInput, isEditorInput, findViewStateForEditor, isResourceEditorInput, isDiffEditorInput, EditorExtensions } from '../editor.js';
+import { EditorInput } from './editorInput.js';
+import { IEditorService } from '../../services/editor/common/editorService.service.js';
+
+var SideBySideEditorInput_1;
+let SideBySideEditorInput = class SideBySideEditorInput extends EditorInput {
+    static { SideBySideEditorInput_1 = this; }
+    static { this.ID = 'workbench.editorinputs.sidebysideEditorInput'; }
+    get typeId() {
+        return SideBySideEditorInput_1.ID;
+    }
+    get capabilities() {
+        let capabilities = this.primary.capabilities;
+        capabilities &= ~EditorInputCapabilities.CanSplitInGroup;
+        if (this.secondary.hasCapability(EditorInputCapabilities.RequiresTrust)) {
+            capabilities |= EditorInputCapabilities.RequiresTrust;
+        }
+        if (this.secondary.hasCapability(EditorInputCapabilities.Singleton)) {
+            capabilities |= EditorInputCapabilities.Singleton;
+        }
+        capabilities |= EditorInputCapabilities.MultipleEditors;
+        return capabilities;
+    }
+    get resource() {
+        if (this.hasIdenticalSides) {
+            return this.primary.resource;
+        }
+        return undefined;
+    }
+    constructor(preferredName, preferredDescription, secondary, primary, editorService) {
+        super();
+        this.preferredName = preferredName;
+        this.preferredDescription = preferredDescription;
+        this.secondary = secondary;
+        this.primary = primary;
+        this.editorService = editorService;
+        this.hasIdenticalSides = this.primary.matches(this.secondary);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(Event.once(Event.any(this.primary.onWillDispose, this.secondary.onWillDispose))(() => {
+            if (!this.isDisposed()) {
+                this.dispose();
+            }
+        }));
+        this._register(this.primary.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+        this._register(this.primary.onDidChangeCapabilities(() => this._onDidChangeCapabilities.fire()));
+        this._register(this.secondary.onDidChangeCapabilities(() => this._onDidChangeCapabilities.fire()));
+        this._register(this.primary.onDidChangeLabel(() => this._onDidChangeLabel.fire()));
+        this._register(this.secondary.onDidChangeLabel(() => this._onDidChangeLabel.fire()));
+    }
+    getName() {
+        const preferredName = this.getPreferredName();
+        if (preferredName) {
+            return preferredName;
+        }
+        if (this.hasIdenticalSides) {
+            return this.primary.getName();
+        }
+        return localize(3943, "{0} - {1}", this.secondary.getName(), this.primary.getName());
+    }
+    getPreferredName() {
+        return this.preferredName;
+    }
+    getDescription(verbosity) {
+        const preferredDescription = this.getPreferredDescription();
+        if (preferredDescription) {
+            return preferredDescription;
+        }
+        if (this.hasIdenticalSides) {
+            return this.primary.getDescription(verbosity);
+        }
+        return super.getDescription(verbosity);
+    }
+    getPreferredDescription() {
+        return this.preferredDescription;
+    }
+    getTitle(verbosity) {
+        let title;
+        if (this.hasIdenticalSides) {
+            title = this.primary.getTitle(verbosity) ?? this.getName();
+        }
+        else {
+            title = super.getTitle(verbosity);
+        }
+        const preferredTitle = this.getPreferredTitle();
+        if (preferredTitle) {
+            title = `${preferredTitle} (${title})`;
+        }
+        return title;
+    }
+    getPreferredTitle() {
+        if (this.preferredName && this.preferredDescription) {
+            return `${this.preferredName} ${this.preferredDescription}`;
+        }
+        if (this.preferredName || this.preferredDescription) {
+            return this.preferredName ?? this.preferredDescription;
+        }
+        return undefined;
+    }
+    getLabelExtraClasses() {
+        if (this.hasIdenticalSides) {
+            return this.primary.getLabelExtraClasses();
+        }
+        return super.getLabelExtraClasses();
+    }
+    getAriaLabel() {
+        if (this.hasIdenticalSides) {
+            return this.primary.getAriaLabel();
+        }
+        return super.getAriaLabel();
+    }
+    getTelemetryDescriptor() {
+        const descriptor = this.primary.getTelemetryDescriptor();
+        return { ...descriptor, ...super.getTelemetryDescriptor() };
+    }
+    isDirty() {
+        return this.primary.isDirty();
+    }
+    isSaving() {
+        return this.primary.isSaving();
+    }
+    async save(group, options) {
+        const primarySaveResult = await this.primary.save(group, options);
+        return this.saveResultToEditor(primarySaveResult);
+    }
+    async saveAs(group, options) {
+        const primarySaveResult = await this.primary.saveAs(group, options);
+        return this.saveResultToEditor(primarySaveResult);
+    }
+    saveResultToEditor(primarySaveResult) {
+        if (!primarySaveResult || !this.hasIdenticalSides) {
+            return primarySaveResult;
+        }
+        if (this.primary.matches(primarySaveResult)) {
+            return this;
+        }
+        if (primarySaveResult instanceof EditorInput) {
+            return ( new SideBySideEditorInput_1(
+                this.preferredName,
+                this.preferredDescription,
+                primarySaveResult,
+                primarySaveResult,
+                this.editorService
+            ));
+        }
+        if (!isResourceDiffEditorInput(primarySaveResult) && !isResourceMultiDiffEditorInput(primarySaveResult) && !isResourceSideBySideEditorInput(primarySaveResult) && !isResourceMergeEditorInput(primarySaveResult)) {
+            return {
+                primary: primarySaveResult,
+                secondary: primarySaveResult,
+                label: this.preferredName,
+                description: this.preferredDescription
+            };
+        }
+        return undefined;
+    }
+    revert(group, options) {
+        return this.primary.revert(group, options);
+    }
+    async rename(group, target) {
+        if (!this.hasIdenticalSides) {
+            return;
+        }
+        const renameResult = await this.primary.rename(group, target);
+        if (!renameResult) {
+            return undefined;
+        }
+        if (isEditorInput(renameResult.editor)) {
+            return {
+                editor: ( new SideBySideEditorInput_1(
+                    this.preferredName,
+                    this.preferredDescription,
+                    renameResult.editor,
+                    renameResult.editor,
+                    this.editorService
+                )),
+                options: {
+                    ...renameResult.options,
+                    viewState: findViewStateForEditor(this, group, this.editorService)
+                }
+            };
+        }
+        if (isResourceEditorInput(renameResult.editor)) {
+            return {
+                editor: {
+                    label: this.preferredName,
+                    description: this.preferredDescription,
+                    primary: renameResult.editor,
+                    secondary: renameResult.editor,
+                    options: {
+                        ...renameResult.options,
+                        viewState: findViewStateForEditor(this, group, this.editorService)
+                    }
+                }
+            };
+        }
+        return undefined;
+    }
+    isReadonly() {
+        return this.primary.isReadonly();
+    }
+    toUntyped(options) {
+        const primaryResourceEditorInput = this.primary.toUntyped(options);
+        const secondaryResourceEditorInput = this.secondary.toUntyped(options);
+        if (primaryResourceEditorInput && secondaryResourceEditorInput &&
+            !isResourceDiffEditorInput(primaryResourceEditorInput) && !isResourceDiffEditorInput(secondaryResourceEditorInput) &&
+            !isResourceMultiDiffEditorInput(primaryResourceEditorInput) && !isResourceMultiDiffEditorInput(secondaryResourceEditorInput) &&
+            !isResourceSideBySideEditorInput(primaryResourceEditorInput) && !isResourceSideBySideEditorInput(secondaryResourceEditorInput) &&
+            !isResourceMergeEditorInput(primaryResourceEditorInput) && !isResourceMergeEditorInput(secondaryResourceEditorInput)) {
+            const untypedInput = {
+                label: this.preferredName,
+                description: this.preferredDescription,
+                primary: primaryResourceEditorInput,
+                secondary: secondaryResourceEditorInput
+            };
+            if (typeof options?.preserveViewState === 'number') {
+                untypedInput.options = {
+                    viewState: findViewStateForEditor(this, options.preserveViewState, this.editorService)
+                };
+            }
+            return untypedInput;
+        }
+        return undefined;
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (isDiffEditorInput(otherInput) || isResourceDiffEditorInput(otherInput)) {
+            return false;
+        }
+        if (otherInput instanceof SideBySideEditorInput_1) {
+            return this.primary.matches(otherInput.primary) && this.secondary.matches(otherInput.secondary);
+        }
+        if (isResourceSideBySideEditorInput(otherInput)) {
+            return this.primary.matches(otherInput.primary) && this.secondary.matches(otherInput.secondary);
+        }
+        return false;
+    }
+};
+SideBySideEditorInput = SideBySideEditorInput_1 = ( __decorate([
+    ( __param(4, IEditorService))
+], SideBySideEditorInput));
+class AbstractSideBySideEditorInputSerializer {
+    canSerialize(editorInput) {
+        const input = editorInput;
+        if (input.primary && input.secondary) {
+            const [secondaryInputSerializer, primaryInputSerializer] = this.getSerializers(input.secondary.typeId, input.primary.typeId);
+            return !!(secondaryInputSerializer?.canSerialize(input.secondary) && primaryInputSerializer?.canSerialize(input.primary));
+        }
+        return false;
+    }
+    serialize(editorInput) {
+        const input = editorInput;
+        if (input.primary && input.secondary) {
+            const [secondaryInputSerializer, primaryInputSerializer] = this.getSerializers(input.secondary.typeId, input.primary.typeId);
+            if (primaryInputSerializer && secondaryInputSerializer) {
+                const primarySerialized = primaryInputSerializer.serialize(input.primary);
+                const secondarySerialized = secondaryInputSerializer.serialize(input.secondary);
+                if (primarySerialized && secondarySerialized) {
+                    const serializedEditorInput = {
+                        name: input.getPreferredName(),
+                        description: input.getPreferredDescription(),
+                        primarySerialized,
+                        secondarySerialized,
+                        primaryTypeId: input.primary.typeId,
+                        secondaryTypeId: input.secondary.typeId
+                    };
+                    return JSON.stringify(serializedEditorInput);
+                }
+            }
+        }
+        return undefined;
+    }
+    deserialize(instantiationService, serializedEditorInput) {
+        const deserialized = JSON.parse(serializedEditorInput);
+        const [secondaryInputSerializer, primaryInputSerializer] = this.getSerializers(deserialized.secondaryTypeId, deserialized.primaryTypeId);
+        if (primaryInputSerializer && secondaryInputSerializer) {
+            const primaryInput = primaryInputSerializer.deserialize(instantiationService, deserialized.primarySerialized);
+            const secondaryInput = secondaryInputSerializer.deserialize(instantiationService, deserialized.secondarySerialized);
+            if (primaryInput instanceof EditorInput && secondaryInput instanceof EditorInput) {
+                return this.createEditorInput(instantiationService, deserialized.name, deserialized.description, secondaryInput, primaryInput);
+            }
+        }
+        return undefined;
+    }
+    getSerializers(secondaryEditorInputTypeId, primaryEditorInputTypeId) {
+        const registry = ( Registry.as(EditorExtensions.EditorFactory));
+        return [registry.getEditorSerializer(secondaryEditorInputTypeId), registry.getEditorSerializer(primaryEditorInputTypeId)];
+    }
+}
+class SideBySideEditorInputSerializer extends AbstractSideBySideEditorInputSerializer {
+    createEditorInput(instantiationService, name, description, secondaryInput, primaryInput) {
+        return instantiationService.createInstance(SideBySideEditorInput, name, description, secondaryInput, primaryInput);
+    }
+}
+
+export { AbstractSideBySideEditorInputSerializer, SideBySideEditorInput, SideBySideEditorInputSerializer };

package/vscode/src/vs/workbench/common/editor/textDiffEditorModel.d.ts

@@ -0,0 +1,18 @@
+import { IDiffEditorModel } from "../../../editor/common/editorCommon.js";
+import { BaseTextEditorModel } from "./textEditorModel.js";
+import { DiffEditorModel } from "./diffEditorModel.js";
+import { IMarkdownString } from "../../../base/common/htmlContent.js";
+export declare class TextDiffEditorModel extends DiffEditorModel {
+    protected readonly _originalModel: BaseTextEditorModel | undefined;
+    get originalModel(): BaseTextEditorModel | undefined;
+    protected readonly _modifiedModel: BaseTextEditorModel | undefined;
+    get modifiedModel(): BaseTextEditorModel | undefined;
+    private _textDiffEditorModel;
+    get textDiffEditorModel(): IDiffEditorModel | undefined;
+    constructor(originalModel: BaseTextEditorModel, modifiedModel: BaseTextEditorModel);
+    resolve(): Promise<void>;
+    private updateTextDiffEditorModel;
+    isResolved(): boolean;
+    isReadonly(): boolean | IMarkdownString;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/common/editor/textDiffEditorModel.js

@@ -0,0 +1,45 @@
+
+import { DiffEditorModel } from './diffEditorModel.js';
+
+class TextDiffEditorModel extends DiffEditorModel {
+    get originalModel() { return this._originalModel; }
+    get modifiedModel() { return this._modifiedModel; }
+    get textDiffEditorModel() { return this._textDiffEditorModel; }
+    constructor(originalModel, modifiedModel) {
+        super(originalModel, modifiedModel);
+        this._textDiffEditorModel = undefined;
+        this._originalModel = originalModel;
+        this._modifiedModel = modifiedModel;
+        this.updateTextDiffEditorModel();
+    }
+    async resolve() {
+        await super.resolve();
+        this.updateTextDiffEditorModel();
+    }
+    updateTextDiffEditorModel() {
+        if (this.originalModel?.isResolved() && this.modifiedModel?.isResolved()) {
+            if (!this._textDiffEditorModel) {
+                this._textDiffEditorModel = {
+                    original: this.originalModel.textEditorModel,
+                    modified: this.modifiedModel.textEditorModel
+                };
+            }
+            else {
+                this._textDiffEditorModel.original = this.originalModel.textEditorModel;
+                this._textDiffEditorModel.modified = this.modifiedModel.textEditorModel;
+            }
+        }
+    }
+    isResolved() {
+        return !!this._textDiffEditorModel;
+    }
+    isReadonly() {
+        return !!this.modifiedModel && this.modifiedModel.isReadonly();
+    }
+    dispose() {
+        this._textDiffEditorModel = undefined;
+        super.dispose();
+    }
+}
+
+export { TextDiffEditorModel };

package/vscode/src/vs/workbench/common/editor/textEditorModel.d.ts

@@ -0,0 +1,47 @@
+import { ITextModel, ITextBufferFactory, ITextSnapshot } from "../../../editor/common/model.js";
+import { EditorModel } from "./editorModel.js";
+import { ILanguageSupport } from "../../services/textfile/common/textfiles.js";
+import { URI } from "../../../base/common/uri.js";
+import { ITextEditorModel, IResolvedTextEditorModel } from "@codingame/monaco-vscode-model-service-override/vscode/vs/editor/common/services/resolverService";
+import { ILanguageSelection } from "../../../editor/common/languages/language.js";
+import { ILanguageService } from "../../../editor/common/languages/language.service.js";
+import { IModelService } from "../../../editor/common/services/model.service.js";
+import { ILanguageDetectionService } from "../../services/languageDetection/common/languageDetectionWorkerService.service.js";
+import { IAccessibilityService } from "../../../platform/accessibility/common/accessibility.service.js";
+import { IMarkdownString } from "../../../base/common/htmlContent.js";
+import { TextModelEditSource } from "../../../editor/common/textModelEditSource.js";
+export declare class BaseTextEditorModel extends EditorModel implements ITextEditorModel, ILanguageSupport {
+    protected modelService: IModelService;
+    protected languageService: ILanguageService;
+    private readonly languageDetectionService;
+    private readonly accessibilityService;
+    private static readonly AUTO_DETECT_LANGUAGE_THROTTLE_DELAY;
+    protected textEditorModelHandle: URI | undefined;
+    private createdEditorModel;
+    private readonly modelDisposeListener;
+    private readonly autoDetectLanguageThrottler;
+    constructor(modelService: IModelService, languageService: ILanguageService, languageDetectionService: ILanguageDetectionService, accessibilityService: IAccessibilityService, textEditorModelHandle?: URI);
+    private handleExistingModel;
+    private registerModelDisposeListener;
+    get textEditorModel(): ITextModel | null;
+    isReadonly(): boolean | IMarkdownString;
+    private _blockLanguageChangeListener;
+    private _languageChangeSource;
+    get languageChangeSource(): "api" | "user" | undefined;
+    get hasLanguageSetExplicitly(): boolean;
+    setLanguageId(languageId: string, source?: string): void;
+    private setLanguageIdInternal;
+    protected installModelListeners(model: ITextModel): void;
+    getLanguageId(): string | undefined;
+    protected autoDetectLanguage(): Promise<void>;
+    private doAutoDetectLanguage;
+    protected createTextEditorModel(value: ITextBufferFactory, resource: URI | undefined, preferredLanguageId?: string): ITextModel;
+    private doCreateTextEditorModel;
+    protected getFirstLineText(value: ITextBufferFactory | ITextModel): string;
+    protected getOrCreateLanguage(resource: URI | undefined, languageService: ILanguageService, preferredLanguage: string | undefined, firstLineText?: string): ILanguageSelection;
+    updateTextEditorModel(newValue?: ITextBufferFactory, preferredLanguageId?: string, reason?: TextModelEditSource): void;
+    createSnapshot(this: IResolvedTextEditorModel): ITextSnapshot;
+    createSnapshot(this: ITextEditorModel): ITextSnapshot | null;
+    isResolved(): this is IResolvedTextEditorModel;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/common/editor/textEditorModel.js

@@ -0,0 +1,181 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { ModelConstants } from '../../../editor/common/model.js';
+import { EditorModel } from './editorModel.js';
+import { ILanguageService } from '../../../editor/common/languages/language.service.js';
+import { IModelService } from '../../../editor/common/services/model.service.js';
+import { MutableDisposable } from '../../../base/common/lifecycle.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../../../editor/common/languages/modesRegistry.js';
+import { LanguageDetectionLanguageEventSource } from '../../services/languageDetection/common/languageDetectionWorkerService.js';
+import { ILanguageDetectionService } from '../../services/languageDetection/common/languageDetectionWorkerService.service.js';
+import { ThrottledDelayer } from '../../../base/common/async.js';
+import { IAccessibilityService } from '../../../platform/accessibility/common/accessibility.service.js';
+import { localize } from '../../../nls.js';
+
+var BaseTextEditorModel_1;
+let BaseTextEditorModel = class BaseTextEditorModel extends EditorModel {
+    static { BaseTextEditorModel_1 = this; }
+    static { this.AUTO_DETECT_LANGUAGE_THROTTLE_DELAY = 600; }
+    constructor(modelService, languageService, languageDetectionService, accessibilityService, textEditorModelHandle) {
+        super();
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.languageDetectionService = languageDetectionService;
+        this.accessibilityService = accessibilityService;
+        this.textEditorModelHandle = undefined;
+        this.modelDisposeListener = this._register(( new MutableDisposable()));
+        this.autoDetectLanguageThrottler = this._register(( new ThrottledDelayer(BaseTextEditorModel_1.AUTO_DETECT_LANGUAGE_THROTTLE_DELAY)));
+        this._blockLanguageChangeListener = false;
+        this._languageChangeSource = undefined;
+        if (textEditorModelHandle) {
+            this.handleExistingModel(textEditorModelHandle);
+        }
+    }
+    handleExistingModel(textEditorModelHandle) {
+        const model = this.modelService.getModel(textEditorModelHandle);
+        if (!model) {
+            throw ( new Error(`Document with resource ${( textEditorModelHandle.toString(true))} does not exist`));
+        }
+        this.textEditorModelHandle = textEditorModelHandle;
+        this.registerModelDisposeListener(model);
+    }
+    registerModelDisposeListener(model) {
+        this.modelDisposeListener.value = model.onWillDispose(() => {
+            this.textEditorModelHandle = undefined;
+            this.dispose();
+        });
+    }
+    get textEditorModel() {
+        return this.textEditorModelHandle ? this.modelService.getModel(this.textEditorModelHandle) : null;
+    }
+    isReadonly() {
+        return true;
+    }
+    get languageChangeSource() { return this._languageChangeSource; }
+    get hasLanguageSetExplicitly() {
+        return typeof this._languageChangeSource === 'string';
+    }
+    setLanguageId(languageId, source) {
+        this._languageChangeSource = 'user';
+        this.setLanguageIdInternal(languageId, source);
+    }
+    setLanguageIdInternal(languageId, source) {
+        if (!this.isResolved()) {
+            return;
+        }
+        if (!languageId || languageId === this.textEditorModel.getLanguageId()) {
+            return;
+        }
+        this._blockLanguageChangeListener = true;
+        try {
+            this.textEditorModel.setLanguage(this.languageService.createById(languageId), source);
+        }
+        finally {
+            this._blockLanguageChangeListener = false;
+        }
+    }
+    installModelListeners(model) {
+        const disposable = this._register(model.onDidChangeLanguage(e => {
+            if (e.source === LanguageDetectionLanguageEventSource ||
+                this._blockLanguageChangeListener) {
+                return;
+            }
+            this._languageChangeSource = 'api';
+            disposable.dispose();
+        }));
+    }
+    getLanguageId() {
+        return this.textEditorModel?.getLanguageId();
+    }
+    autoDetectLanguage() {
+        return this.autoDetectLanguageThrottler.trigger(() => this.doAutoDetectLanguage());
+    }
+    async doAutoDetectLanguage() {
+        if (this.hasLanguageSetExplicitly ||
+            !this.textEditorModelHandle ||
+            !this.languageDetectionService.isEnabledForLanguage(this.getLanguageId() ?? PLAINTEXT_LANGUAGE_ID)
+        ) {
+            return;
+        }
+        const lang = await this.languageDetectionService.detectLanguage(this.textEditorModelHandle);
+        const prevLang = this.getLanguageId();
+        if (lang && lang !== prevLang && !this.isDisposed()) {
+            this.setLanguageIdInternal(lang, LanguageDetectionLanguageEventSource);
+            const languageName = this.languageService.getLanguageName(lang);
+            this.accessibilityService.alert(( localize(
+                3944,
+                "Language {0} was automatically detected and set as the language mode.",
+                languageName ?? lang
+            )));
+        }
+    }
+    createTextEditorModel(value, resource, preferredLanguageId) {
+        const firstLineText = this.getFirstLineText(value);
+        const languageSelection = this.getOrCreateLanguage(resource, this.languageService, preferredLanguageId, firstLineText);
+        return this.doCreateTextEditorModel(value, languageSelection, resource);
+    }
+    doCreateTextEditorModel(value, languageSelection, resource) {
+        let model = resource && this.modelService.getModel(resource);
+        if (!model) {
+            model = this.modelService.createModel(value, languageSelection, resource);
+            this.createdEditorModel = true;
+            this.registerModelDisposeListener(model);
+        }
+        else {
+            this.updateTextEditorModel(value, languageSelection.languageId);
+        }
+        this.textEditorModelHandle = model.uri;
+        return model;
+    }
+    getFirstLineText(value) {
+        const textBufferFactory = value;
+        if (typeof textBufferFactory.getFirstLineText === 'function') {
+            return textBufferFactory.getFirstLineText(ModelConstants.FIRST_LINE_DETECTION_LENGTH_LIMIT);
+        }
+        const textSnapshot = value;
+        return textSnapshot.getLineContent(1).substr(0, ModelConstants.FIRST_LINE_DETECTION_LENGTH_LIMIT);
+    }
+    getOrCreateLanguage(resource, languageService, preferredLanguage, firstLineText) {
+        if (!preferredLanguage || preferredLanguage === PLAINTEXT_LANGUAGE_ID) {
+            return languageService.createByFilepathOrFirstLine(resource ?? null, firstLineText);
+        }
+        return languageService.createById(preferredLanguage);
+    }
+    updateTextEditorModel(newValue, preferredLanguageId, reason) {
+        if (!this.isResolved()) {
+            return;
+        }
+        if (newValue) {
+            this.modelService.updateModel(this.textEditorModel, newValue, reason);
+        }
+        if (preferredLanguageId && preferredLanguageId !== PLAINTEXT_LANGUAGE_ID && this.textEditorModel.getLanguageId() !== preferredLanguageId) {
+            this.textEditorModel.setLanguage(this.languageService.createById(preferredLanguageId));
+        }
+    }
+    createSnapshot() {
+        if (!this.textEditorModel) {
+            return null;
+        }
+        return this.textEditorModel.createSnapshot(true );
+    }
+    isResolved() {
+        return !!this.textEditorModelHandle;
+    }
+    dispose() {
+        this.modelDisposeListener.dispose();
+        if (this.textEditorModelHandle && this.createdEditorModel) {
+            this.modelService.destroyModel(this.textEditorModelHandle);
+        }
+        this.textEditorModelHandle = undefined;
+        this.createdEditorModel = false;
+        super.dispose();
+    }
+};
+BaseTextEditorModel = BaseTextEditorModel_1 = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ILanguageService)),
+    ( __param(2, ILanguageDetectionService)),
+    ( __param(3, IAccessibilityService))
+], BaseTextEditorModel));
+
+export { BaseTextEditorModel };

package/vscode/src/vs/workbench/common/editor.d.ts

@@ -20,7 +20,7 @@ import { IErrorWithActions } from "../../base/common/errorMessage.js";
 import { IAction } from "../../base/common/actions.js";
 import Severity from "../../base/common/severity.js";
 import { IPreferencesService } from "../services/preferences/common/preferences.service.js";
-import { IReadonlyEditorGroupModel } from "@codingame/monaco-vscode-ca445022-b812-53ca-a041-e46c7e0b13de-common/vscode/vs/workbench/common/editor/editorGroupModel";
+import { IReadonlyEditorGroupModel } from "@codingame/monaco-vscode-622c0cca-d5fa-59b6-b730-0715afcf93ee-common/vscode/vs/workbench/common/editor/editorGroupModel";
 export declare const EditorExtensions: {
     EditorPane: string;
     EditorFactory: string;

package/vscode/src/vs/workbench/common/editor.js

@@ -17,8 +17,8 @@ const EditorExtensions = {
 };
 const DEFAULT_EDITOR_ASSOCIATION = {
     id: 'default',
-    displayName: ( localize(3898, "Text Editor")),
-    providerDisplayName: ( localize(3899, "Built-in"))
+    displayName: ( localize(3938, "Text Editor")),
+    providerDisplayName: ( localize(3939, "Built-in"))
 };
 const SIDE_BY_SIDE_EDITOR_ID = 'workbench.editor.sidebysideEditor';
 const TEXT_DIFF_EDITOR_ID = 'workbench.editors.textDiffEditor';
@@ -166,7 +166,7 @@ function isDiffEditorInput(editor) {
 function createTooLargeFileError(group, input, options, message, preferencesService) {
     return createEditorOpenError(message, [
         toAction({
-            id: 'workbench.action.openLargeFile', label: ( localize(3900, "Open Anyway")), run: () => {
+            id: 'workbench.action.openLargeFile', label: ( localize(3940, "Open Anyway")), run: () => {
                 const fileEditorOptions = {
                     ...options,
                     limits: {
@@ -177,7 +177,7 @@ function createTooLargeFileError(group, input, options, message, preferencesServ
             }
         }),
         toAction({
-            id: 'workbench.action.configureEditorLargeFileConfirmation', label: ( localize(3901, "Configure Limit")), run: () => {
+            id: 'workbench.action.configureEditorLargeFileConfirmation', label: ( localize(3941, "Configure Limit")), run: () => {
                 return preferencesService.openUserSettings({ query: 'workbench.editorLargeFileConfirmation' });
             }
         }),

package/vscode/src/vs/workbench/common/theme.d.ts

@@ -114,8 +114,8 @@ export declare const STATUS_BAR_OFFLINE_ITEM_BACKGROUND: string;
 export declare const STATUS_BAR_OFFLINE_ITEM_FOREGROUND: string;
 export declare const STATUS_BAR_OFFLINE_ITEM_HOVER_FOREGROUND: string;
 export declare const STATUS_BAR_OFFLINE_ITEM_HOVER_BACKGROUND: string;
-export declare const EXTENSION_BADGE_REMOTE_BACKGROUND: string;
-export declare const EXTENSION_BADGE_REMOTE_FOREGROUND: string;
+export declare const EXTENSION_BADGE_BACKGROUND: string;
+export declare const EXTENSION_BADGE_FOREGROUND: string;
 export declare const SIDE_BAR_BACKGROUND: string;
 export declare const SIDE_BAR_FOREGROUND: string;
 export declare const SIDE_BAR_BORDER: string;