@theia/monaco 1.24.0-next.46 → 1.24.0-next.49

package/src/browser/monaco-command.ts

@@ -25,6 +25,12 @@ import { MonacoEditorService } from './monaco-editor-service';
 import { MonacoTextModelService } from './monaco-text-model-service';
 import { ProtocolToMonacoConverter } from './protocol-to-monaco-converter';
 import { nls } from '@theia/core/lib/common/nls';
+import { ContextKeyService as VSCodeContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/browser/contextKeyService';
+import { EditorExtensionsRegistry } from '@theia/monaco-editor-core/esm/vs/editor/browser/editorExtensions';
+import { CommandsRegistry, ICommandService } from '@theia/monaco-editor-core/esm/vs/platform/commands/common/commands';
+import * as monaco from '@theia/monaco-editor-core';
+import { EndOfLineSequence } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
 
 export namespace MonacoCommands {
 
@@ -67,8 +73,8 @@ export class MonacoEditorCommandHandlers implements CommandContribution {
     @inject(MonacoTextModelService)
     protected readonly textModelService: MonacoTextModelService;
 
-    @inject(monaco.contextKeyService.ContextKeyService)
-    protected readonly contextKeyService: monaco.contextKeyService.ContextKeyService;
+    @inject(VSCodeContextKeyService)
+    protected readonly contextKeyService: VSCodeContextKeyService;
 
     @inject(ApplicationShell)
     protected readonly shell: ApplicationShell;
@@ -129,12 +135,11 @@ export class MonacoEditorCommandHandlers implements CommandContribution {
      * and execute them using the instantiation service of the current editor.
      */
     protected registerMonacoCommands(): void {
-        const editorRegistry = monaco.editorExtensions.EditorExtensionsRegistry;
-        const editorActions = new Map(editorRegistry.getEditorActions().map(({ id, label }) => [id, label]));
+        const editorActions = new Map(EditorExtensionsRegistry.getEditorActions().map(({ id, label }) => [id, label]));
 
-        const { codeEditorService, textModelService, contextKeyService } = this;
-        const [, globalInstantiationService] = monaco.services.StaticServices.init({ codeEditorService, textModelService, contextKeyService });
-        const monacoCommands = monaco.commands.CommandsRegistry.getCommands();
+        const { codeEditorService } = this;
+        const globalInstantiationService = StandaloneServices.initialize({});
+        const monacoCommands = CommandsRegistry.getCommands();
         for (const id of monacoCommands.keys()) {
             if (MonacoCommands.EXCLUDE_ACTIONS.has(id)) {
                 continue;
@@ -153,13 +158,10 @@ export class MonacoEditorCommandHandlers implements CommandContribution {
                         }
                         return action.run();
                     }
-                    const editorCommand = !!editorRegistry.getEditorCommand(id) ||
-                        !(id.startsWith('_execute') || id === 'setContext' || MonacoCommands.COMMON_ACTIONS.has(id));
-                    const instantiationService = editorCommand ? editor && editor['_instantiationService'] : globalInstantiationService;
-                    if (!instantiationService) {
+                    if (!globalInstantiationService) {
                         return;
                     }
-                    return instantiationService.invokeFunction(
+                    return globalInstantiationService.invokeFunction(
                         monacoCommands.get(id)!.handler,
                         ...args
                     );
@@ -171,7 +173,7 @@ export class MonacoEditorCommandHandlers implements CommandContribution {
                         const action = editor && editor.getAction(id);
                         return !!action && action.isSupported();
                     }
-                    if (!!editorRegistry.getEditorCommand(id)) {
+                    if (!!EditorExtensionsRegistry.getEditorCommand(id)) {
                         return !!editor;
                     }
                     return true;
@@ -199,7 +201,7 @@ export class MonacoEditorCommandHandlers implements CommandContribution {
     protected newShowReferenceHandler(): MonacoEditorCommandHandler {
         return {
             execute: (editor: MonacoEditor, uri: string, position: Position, locations: Location[]) => {
-                editor.commandService.executeCommand(
+                StandaloneServices.get(ICommandService).executeCommand(
                     'editor.action.showReferences',
                     monaco.Uri.parse(uri),
                     this.p2m.asPosition(position),
@@ -242,9 +244,9 @@ export class MonacoEditorCommandHandlers implements CommandContribution {
         const model = editor.document && editor.document.textEditorModel;
         if (model) {
             if (lineEnding === 'CRLF' || lineEnding === '\r\n') {
-                model.pushEOL(monaco.editor.EndOfLineSequence.CRLF);
+                model.pushEOL(EndOfLineSequence.CRLF);
             } else {
-                model.pushEOL(monaco.editor.EndOfLineSequence.LF);
+                model.pushEOL(EndOfLineSequence.LF);
             }
         }
     }

package/src/browser/monaco-context-key-service.ts

@@ -15,16 +15,18 @@
 // *****************************************************************************
 
 import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
-import { ContextKeyService, ContextKey, ContextKeyChangeEvent, ScopedValueStore } from '@theia/core/lib/browser/context-key-service';
+import { ContextKeyService as TheiaContextKeyService, ContextKey, ContextKeyChangeEvent, ScopedValueStore } from '@theia/core/lib/browser/context-key-service';
 import { Emitter } from '@theia/core';
+import { AbstractContextKeyService, ContextKeyService as VSCodeContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/browser/contextKeyService';
+import { ContextKeyExpr, ContextKeyExpression, IContext } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
 
 @injectable()
-export class MonacoContextKeyService implements ContextKeyService {
+export class MonacoContextKeyService implements TheiaContextKeyService {
     protected readonly onDidChangeEmitter = new Emitter<ContextKeyChangeEvent>();
     readonly onDidChange = this.onDidChangeEmitter.event;
 
-    @inject(monaco.contextKeyService.ContextKeyService)
-    protected readonly contextKeyService: monaco.contextKeyService.ContextKeyService;
+    @inject(VSCodeContextKeyService)
+    protected readonly contextKeyService: VSCodeContextKeyService;
 
     @postConstruct()
     protected init(): void {
@@ -39,18 +41,21 @@ export class MonacoContextKeyService implements ContextKeyService {
         return this.contextKeyService.createKey(key, defaultValue);
     }
 
-    activeContext?: HTMLElement | monaco.contextKeyService.IContext;
+    activeContext?: HTMLElement | IContext;
 
     match(expression: string, context?: HTMLElement): boolean {
         const parsed = this.parse(expression);
-        const ctx = this.identifyContext(context);
-        if (!ctx) {
-            return this.contextKeyService.contextMatchesRules(parsed);
+        if (parsed) {
+            const ctx = this.identifyContext(context);
+            if (!ctx) {
+                return this.contextKeyService.contextMatchesRules(parsed);
+            }
+            return parsed.evaluate(ctx);
         }
-        return monaco.keybindings.KeybindingResolver.contextMatchesRules(ctx, parsed);
+        return true;
     }
 
-    protected identifyContext(callersContext?: HTMLElement | monaco.contextKeyService.IContext): monaco.contextKeyService.IContext | undefined {
+    protected identifyContext(callersContext?: HTMLElement | IContext): IContext | undefined {
         if (callersContext && 'getValue' in callersContext) {
             return callersContext;
         } else if (this.activeContext && 'getValue' in this.activeContext) {
@@ -63,11 +68,11 @@ export class MonacoContextKeyService implements ContextKeyService {
         return undefined;
     }
 
-    protected readonly expressions = new Map<string, monaco.contextkey.ContextKeyExpression>();
-    protected parse(when: string): monaco.contextkey.ContextKeyExpression | undefined {
+    protected readonly expressions = new Map<string, ContextKeyExpression>();
+    protected parse(when: string): ContextKeyExpression | undefined {
         let expression = this.expressions.get(when);
         if (!expression) {
-            expression = monaco.contextkey.ContextKeyExpr.deserialize(when);
+            expression = ContextKeyExpr.deserialize(when);
             if (expression) {
                 this.expressions.set(when, expression);
             }
@@ -76,7 +81,7 @@ export class MonacoContextKeyService implements ContextKeyService {
     }
 
     parseKeys(expression: string): Set<string> | undefined {
-        const expr = monaco.contextkey.ContextKeyExpr.deserialize(expression);
+        const expr = ContextKeyExpr.deserialize(expression);
         return expr ? new Set<string>(expr.keys()) : expr;
     }
 
@@ -96,8 +101,12 @@ export class MonacoContextKeyService implements ContextKeyService {
         }
     }
 
-    createScoped(target?: HTMLElement): ScopedValueStore {
-        return this.contextKeyService.createScoped(target);
+    createScoped(target: HTMLElement): ScopedValueStore {
+        const scoped = this.contextKeyService.createScoped(target);
+        if (scoped instanceof AbstractContextKeyService) {
+            return scoped as AbstractContextKeyService & { createScoped(): ScopedValueStore };
+        }
+        return this;
     }
 
     setContext(key: string, value: unknown): void {

package/src/browser/monaco-context-menu.ts

@@ -18,13 +18,25 @@ import { injectable, inject } from '@theia/core/shared/inversify';
 import { MenuPath } from '@theia/core/lib/common/menu';
 import { EDITOR_CONTEXT_MENU } from '@theia/editor/lib/browser';
 import { ContextMenuRenderer, toAnchor } from '@theia/core/lib/browser';
-import IContextMenuService = monaco.editor.IContextMenuService;
-import IContextMenuDelegate = monaco.editor.IContextMenuDelegate;
 import { Menu } from '@theia/core/shared/@phosphor/widgets';
 import { CommandRegistry } from '@theia/core/shared/@phosphor/commands';
+import { IContextMenuService } from '@theia/monaco-editor-core/esm/vs/platform/contextview/browser/contextView';
+import { IContextMenuDelegate } from '@theia/monaco-editor-core/esm/vs/base/browser/contextmenu';
+import { MenuItemAction } from '@theia/monaco-editor-core/esm/vs/platform/actions/common/actions';
+import { Event, Emitter } from '@theia/monaco-editor-core/esm/vs/base/common/event';
 
 @injectable()
 export class MonacoContextMenuService implements IContextMenuService {
+    declare readonly _serviceBrand: undefined;
+
+    protected readonly onDidShowContextMenuEmitter = new Emitter<void>();
+    get onDidShowContextMenu(): Event<void> {
+        return this.onDidShowContextMenuEmitter.event;
+    };
+    protected readonly onDidHideContextMenuEmitter = new Emitter<void>();
+    get onDidHideContextMenu(): Event<void> {
+        return this.onDidShowContextMenuEmitter.event;
+    };
 
     constructor(@inject(ContextMenuRenderer) protected readonly contextMenuRenderer: ContextMenuRenderer) {
     }
@@ -32,14 +44,18 @@ export class MonacoContextMenuService implements IContextMenuService {
     showContextMenu(delegate: IContextMenuDelegate): void {
         const anchor = toAnchor(delegate.getAnchor());
         const actions = delegate.getActions();
+        const onHide = () => {
+            delegate.onHide?.(false);
+            this.onDidHideContextMenuEmitter.fire();
+        };
 
         // Actions for editor context menu come as 'MenuItemAction' items
         // In case of 'Quick Fix' actions come as 'CodeActionAction' items
-        if (actions.length > 0 && actions[0] instanceof monaco.actions.MenuItemAction) {
+        if (actions.length > 0 && actions[0] instanceof MenuItemAction) {
             this.contextMenuRenderer.render({
                 menuPath: this.menuPath(),
                 anchor,
-                onHide: () => delegate.onHide(false)
+                onHide
             });
         } else {
             const commands = new CommandRegistry();
@@ -52,7 +68,7 @@ export class MonacoContextMenuService implements IContextMenuService {
                 commands.addCommand(commandId, {
                     label: action.label,
                     className: action.class,
-                    isToggled: () => action.checked,
+                    isToggled: () => Boolean(action.checked),
                     isEnabled: () => action.enabled,
                     execute: () => action.run()
                 });
@@ -61,9 +77,10 @@ export class MonacoContextMenuService implements IContextMenuService {
                     command: commandId
                 });
             }
-            menu.aboutToClose.connect(() => delegate.onHide(false));
+            menu.aboutToClose.connect(() => onHide);
             menu.open(anchor.x, anchor.y);
         }
+        this.onDidShowContextMenuEmitter.fire();
     }
 
     protected menuPath(): MenuPath {

package/src/browser/monaco-diagnostic-collection.ts

@@ -17,8 +17,7 @@
 import { Diagnostic } from '@theia/core/shared/vscode-languageserver-protocol';
 import { DisposableCollection, Disposable } from '@theia/core/lib/common/disposable';
 import { ProtocolToMonacoConverter } from './protocol-to-monaco-converter';
-import IModel = monaco.editor.IModel;
-import IMarkerData = monaco.editor.IMarkerData;
+import * as monaco from '@theia/monaco-editor-core';
 
 export class MonacoDiagnosticCollection implements Disposable {
 
@@ -57,7 +56,7 @@ export class MonacoDiagnosticCollection implements Disposable {
 
 export class MonacoModelDiagnostics implements Disposable {
     readonly uri: monaco.Uri;
-    protected _markers: IMarkerData[] = [];
+    protected _markers: monaco.editor.IMarkerData[] = [];
     protected _diagnostics: Diagnostic[] = [];
     constructor(
         uri: string,
@@ -80,7 +79,7 @@ export class MonacoModelDiagnostics implements Disposable {
         return this._diagnostics;
     }
 
-    get markers(): ReadonlyArray<IMarkerData> {
+    get markers(): ReadonlyArray<monaco.editor.IMarkerData> {
         return this._markers;
     }
 
@@ -94,7 +93,7 @@ export class MonacoModelDiagnostics implements Disposable {
         this.doUpdateModelMarkers(model ? model : undefined);
     }
 
-    protected doUpdateModelMarkers(model: IModel | undefined): void {
+    protected doUpdateModelMarkers(model: monaco.editor.ITextModel | undefined): void {
         if (model && this.uri.toString() === model.uri.toString()) {
             monaco.editor.setModelMarkers(model, this.owner, this._markers);
         }

package/src/browser/monaco-diff-editor.ts

@@ -18,14 +18,13 @@ import URI from '@theia/core/lib/common/uri';
 import { Disposable } from '@theia/core/lib/common';
 import { Dimension, DiffNavigator, DeltaDecorationParams } from '@theia/editor/lib/browser';
 import { MonacoEditorModel } from './monaco-editor-model';
-import { MonacoEditor, MonacoEditorServices } from './monaco-editor';
+import { EditorServiceOverrides, MonacoEditor, MonacoEditorServices } from './monaco-editor';
 import { MonacoDiffNavigatorFactory } from './monaco-diff-navigator-factory';
 import { DiffUris } from '@theia/core/lib/browser/diff-uris';
-
-import IStandaloneDiffEditor = monaco.editor.IStandaloneDiffEditor;
-import IDiffEditorConstructionOptions = monaco.editor.IDiffEditorConstructionOptions;
-import IDiffNavigatorOptions = monaco.editor.IDiffNavigatorOptions;
-import IEditorOverrideServices = monaco.editor.IEditorOverrideServices;
+import * as monaco from '@theia/monaco-editor-core';
+import { IDiffEditorConstructionOptions } from '@theia/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
+import { IDiffNavigatorOptions } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneEditor';
+import { StandaloneDiffEditor } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditor';
 
 export namespace MonacoDiffEditor {
     export interface IOptions extends MonacoEditor.ICommonOptions, IDiffEditorConstructionOptions, IDiffNavigatorOptions {
@@ -33,7 +32,7 @@ export namespace MonacoDiffEditor {
 }
 
 export class MonacoDiffEditor extends MonacoEditor {
-    protected _diffEditor: IStandaloneDiffEditor;
+    protected _diffEditor: monaco.editor.IStandaloneDiffEditor;
     protected _diffNavigator: DiffNavigator;
 
     constructor(
@@ -44,7 +43,7 @@ export class MonacoDiffEditor extends MonacoEditor {
         services: MonacoEditorServices,
         protected readonly diffNavigatorFactory: MonacoDiffNavigatorFactory,
         options?: MonacoDiffEditor.IOptions,
-        override?: IEditorOverrideServices,
+        override?: EditorServiceOverrides,
     ) {
         super(uri, modifiedModel, node, services, options, override);
         this.documents.add(originalModel);
@@ -54,7 +53,7 @@ export class MonacoDiffEditor extends MonacoEditor {
         this._diffEditor.setModel({ original, modified });
     }
 
-    get diffEditor(): IStandaloneDiffEditor {
+    get diffEditor(): monaco.editor.IStandaloneDiffEditor {
         return this._diffEditor;
     }
 
@@ -62,11 +61,10 @@ export class MonacoDiffEditor extends MonacoEditor {
         return this._diffNavigator;
     }
 
-    protected override create(options?: IDiffEditorConstructionOptions, override?: monaco.editor.IEditorOverrideServices): Disposable {
-        this._diffEditor = monaco.editor.createDiffEditor(this.node, <IDiffEditorConstructionOptions>{
-            ...options,
-            fixedOverflowWidgets: true
-        }, override);
+    protected override create(options?: IDiffEditorConstructionOptions, override?: EditorServiceOverrides): Disposable {
+        const instantiator = this.getInstantiatorWithOverrides(override);
+        this._diffEditor = instantiator
+            .createInstance(StandaloneDiffEditor, this.node, { ...options, fixedOverflowWidgets: true }) as unknown as monaco.editor.IStandaloneDiffEditor;
         this.editor = this._diffEditor.getModifiedEditor();
         return this._diffEditor;
     }

package/src/browser/monaco-diff-navigator-factory.ts

@@ -16,9 +16,9 @@
 
 import { injectable } from '@theia/core/shared/inversify';
 import { DiffNavigator } from '@theia/editor/lib/browser';
-
-import IStandaloneDiffEditor = monaco.editor.IStandaloneDiffEditor;
-import IDiffNavigatorOptions = monaco.editor.IDiffNavigatorOptions;
+import * as monaco from '@theia/monaco-editor-core';
+import { DiffNavigator as MonacoDiffNavigator } from '@theia/monaco-editor-core/esm/vs/editor/browser/widget/diffNavigator';
+import { IStandaloneDiffEditor } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditor';
 
 @injectable()
 export class MonacoDiffNavigatorFactory {
@@ -29,29 +29,33 @@ export class MonacoDiffNavigatorFactory {
         hasPrevious: () => false,
         next: () => { },
         previous: () => { },
-        revealFirst: false,
     };
 
-    createdDiffNavigator(editor: IStandaloneDiffEditor, options?: IDiffNavigatorOptions): DiffNavigator {
-        const navigator = monaco.editor.createDiffNavigator(editor, options);
+    createdDiffNavigator(editor: IStandaloneDiffEditor | monaco.editor.IStandaloneDiffEditor, options?: monaco.editor.IDiffNavigatorOptions): DiffNavigator {
+        const navigator = new MonacoDiffNavigator(editor as IStandaloneDiffEditor, options);
         const ensureInitialized = (fwd: boolean) => {
-            if (navigator.nextIdx < -1) {
-                navigator._initIdx(fwd);
+            if (navigator['nextIdx'] < 0) {
+                navigator['_initIdx'](fwd);
             }
         };
-        return <DiffNavigator>{
+        return {
             canNavigate: () => navigator.canNavigate(),
             hasNext: () => {
-                ensureInitialized(true);
-                return navigator.nextIdx + 1 < navigator.ranges.length;
+                if (navigator.canNavigate()) {
+                    ensureInitialized(true);
+                    return navigator['nextIdx'] + 1 < navigator['ranges'].length;
+                }
+                return false;
             },
             hasPrevious: () => {
-                ensureInitialized(false);
-                return navigator.nextIdx > 0;
+                if (navigator.canNavigate()) {
+                    ensureInitialized(false);
+                    return navigator['nextIdx'] > 0;
+                }
+                return false;
             },
             next: () => navigator.next(),
             previous: () => navigator.previous(),
-            revealFirst: navigator.revealFirst,
         };
     }
 }

package/src/browser/monaco-editor-model.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { Position, Range, TextDocumentSaveReason, TextDocumentContentChangeEvent } from '@theia/core/shared/vscode-languageserver-protocol';
-import { TextEditorDocument, EncodingMode, FindMatchesOptions, FindMatch, EditorPreferences, DEFAULT_WORD_SEPARATORS } from '@theia/editor/lib/browser';
+import { TextEditorDocument, EncodingMode, FindMatchesOptions, FindMatch, EditorPreferences } from '@theia/editor/lib/browser';
 import { DisposableCollection, Disposable } from '@theia/core/lib/common/disposable';
 import { Emitter, Event } from '@theia/core/lib/common/event';
 import { CancellationTokenSource, CancellationToken } from '@theia/core/lib/common/cancellation';
@@ -24,18 +24,24 @@ import { Saveable, SaveOptions } from '@theia/core/lib/browser/saveable';
 import { MonacoToProtocolConverter } from './monaco-to-protocol-converter';
 import { ProtocolToMonacoConverter } from './protocol-to-monaco-converter';
 import { ILogger, Loggable, Log } from '@theia/core/lib/common/logger';
+import { IIdentifiedSingleEditOperation, ITextBufferFactory, ITextModel, ITextSnapshot } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
+import { IResolvedTextEditorModel } from '@theia/monaco-editor-core/esm/vs/editor/common/services/resolverService';
+import * as monaco from '@theia/monaco-editor-core';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { ILanguageService } from '@theia/monaco-editor-core/esm/vs/editor/common/languages/language';
+import { IModelService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/model';
+import { createTextBufferFactoryFromStream } from '@theia/monaco-editor-core/esm/vs/editor/common/model/textModel';
+import { editorGeneratedPreferenceProperties } from '@theia/editor/lib/browser/editor-generated-preference-schema';
 
 export {
     TextDocumentSaveReason
 };
 
-type ITextEditorModel = monaco.editor.ITextEditorModel;
-
 export interface WillSaveMonacoModelEvent {
     readonly model: MonacoEditorModel;
     readonly reason: TextDocumentSaveReason;
     readonly options?: SaveOptions;
-    waitUntil(thenable: Thenable<monaco.editor.IIdentifiedSingleEditOperation[]>): void;
+    waitUntil(thenable: Thenable<IIdentifiedSingleEditOperation[]>): void;
 }
 
 export interface MonacoModelContentChangedEvent {
@@ -43,10 +49,10 @@ export interface MonacoModelContentChangedEvent {
     readonly contentChanges: TextDocumentContentChangeEvent[];
 }
 
-export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
+export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDocument {
 
-    autoSave: 'on' | 'off' = 'on';
-    autoSaveDelay: number = 500;
+    autoSave: EditorPreferences['files.autoSave'] = 'afterDelay';
+    autoSaveDelay = 500;
     suppressOpenEditorWhenDirty = false;
     lineNumbersMinChars = 3;
 
@@ -54,7 +60,7 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
     readonly onWillSaveLoopTimeOut = 1500;
     protected bufferSavedVersionId: number;
 
-    protected model: monaco.editor.IModel;
+    protected model: ITextModel;
     protected readonly resolveModel: Promise<void>;
 
     protected readonly toDispose = new DisposableCollection();
@@ -63,7 +69,7 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
     protected readonly onDidChangeContentEmitter = new Emitter<MonacoModelContentChangedEvent>();
     readonly onDidChangeContent = this.onDidChangeContentEmitter.event;
 
-    protected readonly onDidSaveModelEmitter = new Emitter<monaco.editor.IModel>();
+    protected readonly onDidSaveModelEmitter = new Emitter<ITextModel>();
     readonly onDidSaveModel = this.onDidSaveModelEmitter.event;
 
     protected readonly onWillSaveModelEmitter = new Emitter<WillSaveMonacoModelEvent>();
@@ -105,6 +111,18 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
         this.toDispose.dispose();
     }
 
+    isDisposed(): boolean {
+        return this.toDispose.disposed;
+    }
+
+    resolve(): Promise<void> {
+        return this.resolveModel;
+    }
+
+    isResolved(): boolean {
+        return Boolean(this.model);
+    }
+
     setEncoding(encoding: string, mode: EncodingMode): Promise<void> {
         if (mode === EncodingMode.Decode && this.dirty) {
             return Promise.resolve();
@@ -147,7 +165,7 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
      * Only this method can create an instance of `monaco.editor.IModel`,
      * there should not be other calls to `monaco.editor.createModel`.
      */
-    protected initialize(value: string | monaco.editor.ITextBufferFactory): void {
+    protected initialize(value: string | ITextBufferFactory): void {
         if (!this.toDispose.disposed) {
             const uri = monaco.Uri.parse(this.resource.uri.toString());
             let firstLine;
@@ -160,8 +178,8 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
             } else {
                 firstLine = value.getFirstLineText(1000);
             }
-            const languageSelection = monaco.services.StaticServices.modeService.get().createByFilepathOrFirstLine(uri, firstLine);
-            this.model = monaco.services.StaticServices.modelService.get().createModel(value, languageSelection, uri);
+            const languageSelection = StandaloneServices.get(ILanguageService).createByFilepathOrFirstLine(uri, firstLine);
+            this.model = StandaloneServices.get(IModelService).createModel(value, languageSelection, uri);
             this.resourceVersion = this.resource.version;
             this.updateSavedVersionId();
             this.toDispose.push(this.model);
@@ -221,10 +239,15 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
 
     protected _languageId: string | undefined;
     get languageId(): string {
-        return this._languageId !== undefined ? this._languageId : this.model.getModeId();
+        return this._languageId !== undefined ? this._languageId : this.model.getLanguageId();
+    }
+
+    getLanguageId(): string | undefined {
+        return this.languageId;
     }
+
     /**
-     * It's a hack to dispatch close notification with an old language id, don't use it.
+     * It's a hack to dispatch close notification with an old language id; don't use it.
      */
     setLanguageId(languageId: string | undefined): void {
         this._languageId = languageId;
@@ -273,11 +296,22 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
         return this.resource.saveContents === undefined;
     }
 
+    isReadonly(): boolean {
+        return this.readOnly;
+    }
+
     get onDispose(): monaco.IEvent<void> {
         return this.toDispose.onDispose;
     }
 
-    get textEditorModel(): monaco.editor.IModel {
+    get onWillDispose(): Event<void> {
+        return this.toDispose.onDispose;
+    }
+
+    // We have a TypeScript problem here. There is a const enum `DefaultEndOfLine` used for ITextModel and a non-const redeclaration of that enum in the public API in
+    // Monaco.editor. The values will be the same, but TS won't accept that the two enums are equivalent, so it says these types are irreconcilable.
+    get textEditorModel(): monaco.editor.ITextModel & ITextModel {
+        // @ts-expect-error ts(2322)
         return this.model;
     }
 
@@ -288,7 +322,7 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
      * @returns the list of matches.
      */
     findMatches(options: FindMatchesOptions): FindMatch[] {
-        const wordSeparators = this.editorPreferences ? this.editorPreferences['editor.wordSeparators'] : DEFAULT_WORD_SEPARATORS;
+        const wordSeparators = this.editorPreferences?.['editor.wordSeparators'] ?? editorGeneratedPreferenceProperties['editor.wordSeparators'].default as string;
         const results: monaco.editor.FindMatch[] = this.model.findMatches(
             options.searchString,
             false,
@@ -368,13 +402,13 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
         }
 
         this.resourceVersion = this.resource.version;
-        this.updateModel(() => monaco.services.StaticServices.modelService.get().updateModel(this.model, value), {
+        this.updateModel(() => StandaloneServices.get(IModelService).updateModel(this.model, value), {
             ignoreDirty: true,
             ignoreContentChanges: true
         });
         this.trace(log => log('MonacoEditorModel.doSync - exit'));
     }
-    protected async readContents(): Promise<string | monaco.editor.ITextBufferFactory | undefined> {
+    protected async readContents(): Promise<string | ITextBufferFactory | undefined> {
         try {
             const options = { encoding: this.getEncoding() };
             const content = await (this.resource.readStream ? this.resource.readStream(options) : this.resource.readContents(options));
@@ -382,7 +416,7 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
             if (typeof content === 'string') {
                 value = content;
             } else {
-                value = monaco.textModel.createTextBufferFactoryFromStream(content);
+                value = createTextBufferFactoryFromStream(content);
             }
             this.updateContentEncoding();
             this.setValid(true);
@@ -410,7 +444,7 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
     }
 
     protected doAutoSave(): void {
-        if (this.autoSave === 'on') {
+        if (this.autoSave !== 'off') {
             const token = this.cancelSave();
             this.toDisposeOnAutoSave.dispose();
             const handle = window.setTimeout(() => {
@@ -611,10 +645,8 @@ export class MonacoEditorModel implements ITextEditorModel, TextEditorDocument {
         this.trace(log => log('MonacoEditorModel.revert - exit'));
     }
 
-    createSnapshot(): object {
-        return {
-            value: this.getText()
-        };
+    createSnapshot(preserveBOM?: boolean): ITextSnapshot {
+        return this.model.createSnapshot(preserveBOM);
     }
 
     applySnapshot(snapshot: { value: string }): void {