@codingame/monaco-vscode-api 37.0.0 → 37.2.0

package/vscode/src/vs/platform/undoRedo/common/undoRedoService.js

@@ -72,14 +72,14 @@ class RemovedResources {
         const messages = [];
         if (externalRemoval.length > 0) {
             messages.push(( localize(
-                2820,
+                2866,
                 "The following files have been closed and modified on disk: {0}.",
                 externalRemoval.join(", ")
             )));
         }
         if (noParallelUniverses.length > 0) {
             messages.push(( localize(
-                2821,
+                2867,
                 "The following files have been modified in an incompatible way: {0}.",
                 noParallelUniverses.join(", ")
             )));
@@ -724,7 +724,7 @@ let UndoRedoService = class UndoRedoService {
     _checkWorkspaceUndo(strResource, element, editStackSnapshot, checkInvalidatedResources) {
         if (element.removedResources) {
             return this._tryToSplitAndUndo(strResource, element, element.removedResources, ( localize(
-                2822,
+                2868,
                 "Could not undo '{0}' across all files. {1}",
                 element.label,
                 element.removedResources.createMessage()
@@ -732,7 +732,7 @@ let UndoRedoService = class UndoRedoService {
         }
         if (checkInvalidatedResources && element.invalidatedResources) {
             return this._tryToSplitAndUndo(strResource, element, element.invalidatedResources, ( localize(
-                2822,
+                2868,
                 "Could not undo '{0}' across all files. {1}",
                 element.label,
                 element.invalidatedResources.createMessage()
@@ -746,7 +746,7 @@ let UndoRedoService = class UndoRedoService {
         }
         if (cannotUndoDueToResources.length > 0) {
             return this._tryToSplitAndUndo(strResource, element, null, ( localize(
-                2823,
+                2869,
                 "Could not undo '{0}' across all files because changes were made to {1}",
                 element.label,
                 cannotUndoDueToResources.join(", ")
@@ -760,7 +760,7 @@ let UndoRedoService = class UndoRedoService {
         }
         if (cannotLockDueToResources.length > 0) {
             return this._tryToSplitAndUndo(strResource, element, null, ( localize(
-                2824,
+                2870,
                 "Could not undo '{0}' across all files because there is already an undo or redo operation running on {1}",
                 element.label,
                 cannotLockDueToResources.join(", ")
@@ -768,7 +768,7 @@ let UndoRedoService = class UndoRedoService {
         }
         if (!editStackSnapshot.isValid()) {
             return this._tryToSplitAndUndo(strResource, element, null, ( localize(
-                2825,
+                2871,
                 "Could not undo '{0}' across all files because an undo or redo operation occurred in the meantime",
                 element.label
             )));
@@ -821,12 +821,12 @@ let UndoRedoService = class UndoRedoService {
                 result
             } = await this._dialogService.prompt({
                 type: Severity$1.Info,
-                message: ( localize(2826, "Would you like to undo '{0}' across all files?", element.label)),
+                message: ( localize(2872, "Would you like to undo '{0}' across all files?", element.label)),
                 buttons: [{
-                    label: ( localize(2827, "&&Undo in {0} Files", editStackSnapshot.editStacks.length)),
+                    label: ( localize(2873, "&&Undo in {0} Files", editStackSnapshot.editStacks.length)),
                     run: () => UndoChoice.All
                 }, {
-                    label: ( localize(2828, "Undo this &&File")),
+                    label: ( localize(2874, "Undo this &&File")),
                     run: () => UndoChoice.This
                 }],
                 cancelButton: {
@@ -885,7 +885,7 @@ let UndoRedoService = class UndoRedoService {
         }
         if (editStack.locked) {
             const message = ( localize(
-                2829,
+                2875,
                 "Could not undo '{0}' because there is already an undo or redo operation running.",
                 element.label
             ));
@@ -966,9 +966,9 @@ let UndoRedoService = class UndoRedoService {
     }
     async _confirmAndContinueUndo(strResource, sourceId, element) {
         const result = await this._dialogService.confirm({
-            message: ( localize(2830, "Would you like to undo '{0}'?", element.label)),
-            primaryButton: ( localize(2831, "&&Yes")),
-            cancelButton: ( localize(2832, "No"))
+            message: ( localize(2876, "Would you like to undo '{0}'?", element.label)),
+            primaryButton: ( localize(2877, "&&Yes")),
+            cancelButton: ( localize(2878, "No"))
         });
         if (!result.confirmed) {
             return;
@@ -1023,7 +1023,7 @@ let UndoRedoService = class UndoRedoService {
     _checkWorkspaceRedo(strResource, element, editStackSnapshot, checkInvalidatedResources) {
         if (element.removedResources) {
             return this._tryToSplitAndRedo(strResource, element, element.removedResources, ( localize(
-                2833,
+                2879,
                 "Could not redo '{0}' across all files. {1}",
                 element.label,
                 element.removedResources.createMessage()
@@ -1031,7 +1031,7 @@ let UndoRedoService = class UndoRedoService {
         }
         if (checkInvalidatedResources && element.invalidatedResources) {
             return this._tryToSplitAndRedo(strResource, element, element.invalidatedResources, ( localize(
-                2833,
+                2879,
                 "Could not redo '{0}' across all files. {1}",
                 element.label,
                 element.invalidatedResources.createMessage()
@@ -1045,7 +1045,7 @@ let UndoRedoService = class UndoRedoService {
         }
         if (cannotRedoDueToResources.length > 0) {
             return this._tryToSplitAndRedo(strResource, element, null, ( localize(
-                2834,
+                2880,
                 "Could not redo '{0}' across all files because changes were made to {1}",
                 element.label,
                 cannotRedoDueToResources.join(", ")
@@ -1059,7 +1059,7 @@ let UndoRedoService = class UndoRedoService {
         }
         if (cannotLockDueToResources.length > 0) {
             return this._tryToSplitAndRedo(strResource, element, null, ( localize(
-                2835,
+                2881,
                 "Could not redo '{0}' across all files because there is already an undo or redo operation running on {1}",
                 element.label,
                 cannotLockDueToResources.join(", ")
@@ -1067,7 +1067,7 @@ let UndoRedoService = class UndoRedoService {
         }
         if (!editStackSnapshot.isValid()) {
             return this._tryToSplitAndRedo(strResource, element, null, ( localize(
-                2836,
+                2882,
                 "Could not redo '{0}' across all files because an undo or redo operation occurred in the meantime",
                 element.label
             )));
@@ -1122,7 +1122,7 @@ let UndoRedoService = class UndoRedoService {
         }
         if (editStack.locked) {
             const message = ( localize(
-                2837,
+                2883,
                 "Could not redo '{0}' because there is already an undo or redo operation running.",
                 element.label
             ));

package/vscode/src/vs/platform/userDataProfile/common/userDataProfile.js

@@ -227,7 +227,7 @@ let UserDataProfilesService = class UserDataProfilesService extends Disposable {
         return false;
     }
     createDefaultProfile() {
-        const defaultProfile = toUserDataProfile("__default__profile__", ( localize(2850, "Default")), this.environmentService.userRoamingDataHome, this.profilesCacheHome);
+        const defaultProfile = toUserDataProfile("__default__profile__", ( localize(2896, "Default")), this.environmentService.userRoamingDataHome, this.profilesCacheHome);
         return {
             ...defaultProfile,
             extensionsResource: this.getDefaultProfileExtensionsLocation() ?? defaultProfile.extensionsResource,

package/vscode/src/vs/platform/userDataSync/common/abstractSynchronizer.js

@@ -283,7 +283,7 @@ let AbstractSynchroniser = class AbstractSynchroniser extends Disposable {
     async performSync(remoteUserData, lastSyncUserData, strategy, userDataSyncConfiguration) {
         if (remoteUserData.syncData && remoteUserData.syncData.version > this.version) {
             throw ( new UserDataSyncError(( localize(
-                2851,
+                2897,
                 "Cannot sync {0} as its local version {1} is not compatible with its remote version {2}",
                 this.resource,
                 this.version,
@@ -720,7 +720,7 @@ let AbstractSynchroniser = class AbstractSynchroniser extends Disposable {
             this.logService.error(error);
         }
         throw ( new UserDataSyncError(( localize(
-            2852,
+            2898,
             "Cannot parse sync data as it is not compatible with the current version."
         )), UserDataSyncErrorCode.IncompatibleRemoteContent, this.resource));
     }

package/vscode/src/vs/platform/userDataSync/common/keybindingsSync.js

@@ -106,7 +106,7 @@ let KeybindingsSynchroniser = class KeybindingsSynchroniser extends AbstractJson
             localContent = localContent || "[]";
             if (this.hasErrors(localContent, true)) {
                 throw ( new UserDataSyncError(( localize(
-                    2853,
+                    2899,
                     "Unable to sync keybindings because the content in the file is not valid. Please open the file and correct it."
                 )), UserDataSyncErrorCode.LocalInvalidContent, this.resource));
             }
@@ -230,7 +230,7 @@ let KeybindingsSynchroniser = class KeybindingsSynchroniser extends AbstractJson
             content = content || "[]";
             if (this.hasErrors(content, true)) {
                 throw ( new UserDataSyncError(( localize(
-                    2853,
+                    2899,
                     "Unable to sync keybindings because the content in the file is not valid. Please open the file and correct it."
                 )), UserDataSyncErrorCode.LocalInvalidContent, this.resource));
             }

package/vscode/src/vs/platform/userDataSync/common/settingsSync.js

@@ -348,7 +348,7 @@ let SettingsSynchroniser = class SettingsSynchroniser extends AbstractJsonFileSy
     validateContent(content) {
         if (this.hasErrors(content, false)) {
             throw ( new UserDataSyncError(( localize(
-                2854,
+                2900,
                 "Unable to sync settings as there are errors/warning in settings file."
             )), UserDataSyncErrorCode.LocalInvalidContent, this.resource));
         }

package/vscode/src/vs/platform/userDataSync/common/userDataSync.js

@@ -49,12 +49,12 @@ function registerConfiguration() {
     configurationRegistry.registerConfiguration({
         id: "settingsSync",
         order: 30,
-        title: ( localize(2860, "Settings Sync")),
+        title: ( localize(2906, "Settings Sync")),
         type: "object",
         properties: {
             [CONFIG_SYNC_KEYBINDINGS_PER_PLATFORM]: {
                 type: "boolean",
-                description: ( localize(2861, "Synchronize keybindings for each platform.")),
+                description: ( localize(2907, "Synchronize keybindings for each platform.")),
                 default: true,
                 scope: ConfigurationScope.APPLICATION,
                 tags: ["sync", "usesOnlineServices"]
@@ -62,13 +62,13 @@ function registerConfiguration() {
             "settingsSync.ignoredExtensions": {
                 "type": "array",
                 markdownDescription: ( localize(
-                    2862,
+                    2908,
                     "List of extensions to be ignored while synchronizing. The identifier of an extension is always `${publisher}.${name}`. For example: `vscode.csharp`."
                 )),
                 items: [{
                     type: "string",
                     pattern: EXTENSION_IDENTIFIER_PATTERN,
-                    errorMessage: ( localize(2863, "Expected format '${publisher}.${name}'. Example: 'vscode.csharp'."))
+                    errorMessage: ( localize(2909, "Expected format '${publisher}.${name}'. Example: 'vscode.csharp'."))
                 }],
                 "default": [],
                 "scope": ConfigurationScope.APPLICATION,
@@ -78,7 +78,7 @@ function registerConfiguration() {
             },
             "settingsSync.ignoredSettings": {
                 "type": "array",
-                description: ( localize(2864, "Configure settings to be ignored while synchronizing.")),
+                description: ( localize(2910, "Configure settings to be ignored while synchronizing.")),
                 "default": [],
                 "scope": ConfigurationScope.APPLICATION,
                 $ref: ignoredSettingsSchemaId,

package/vscode/src/vs/platform/userDataSync/common/userDataSyncMachines.js

@@ -171,7 +171,7 @@ let UserDataSyncMachinesService = class UserDataSyncMachinesService extends Disp
         const machinesData = this.parse(this.userData);
         if (machinesData.version !== UserDataSyncMachinesService_1.VERSION) {
             throw ( new Error(( localize(
-                2866,
+                2912,
                 "Cannot read machines data as the current version is incompatible. Please update {0} and try again.",
                 this.productService.nameLong
             ))));

package/vscode/src/vs/platform/webWorker/browser/webWorkerServiceImpl.js

@@ -73,8 +73,8 @@ function createBlobWorker(blobUrl, options) {
         throw ( new URIError("Not a blob-url: " + blobUrl));
     }
     return ( new Worker(ttPolicy ? ttPolicy.createScriptURL(blobUrl) : blobUrl, {
-        ...options,
-        type: "module"
+        type: "module",
+        ...options
     }));
 }
 function getWorkerBootstrapUrl(label, workerScriptUrl, workerLoadingFailedErrorMessage, workerOptions) {

package/vscode/src/vs/platform/workspace/common/workspace.js

@@ -156,7 +156,7 @@ function toWorkspaceFolder(resource) {
 const WORKSPACE_EXTENSION = "code-workspace";
 const WORKSPACE_SUFFIX = `.${WORKSPACE_EXTENSION}`;
 const WORKSPACE_FILTER = [{
-    name: ( localize(2868, "Code Workspace")),
+    name: ( localize(2914, "Code Workspace")),
     extensions: [WORKSPACE_EXTENSION]
 }];
 const UNTITLED_WORKSPACE_NAME = "workspace.json";

package/vscode/src/vs/workbench/api/browser/mainThreadDocuments.d.ts

@@ -0,0 +1,63 @@
+import { IReference, Disposable } from "../../../base/common/lifecycle.js";
+import { URI, UriComponents } from "../../../base/common/uri.js";
+import { ITextModel } from "../../../editor/common/model.js";
+import { IModelService } from "../../../editor/common/services/model.service.js";
+import { ITextModelService } from "../../../editor/common/services/resolverService.service.js";
+import { IFileService } from "../../../platform/files/common/files.service.js";
+import { MainThreadDocumentsShape } from "../common/extHost.protocol.js";
+import { ITextFileService } from "../../services/textfile/common/textfiles.service.js";
+import { IWorkbenchEnvironmentService } from "../../services/environment/common/environmentService.service.js";
+import { IExtUri } from "../../../base/common/resources.js";
+import { IWorkingCopyFileService } from "../../services/workingCopy/common/workingCopyFileService.service.js";
+import { IUriIdentityService } from "../../../platform/uriIdentity/common/uriIdentity.service.js";
+import { Event } from "../../../base/common/event.js";
+import { IPathService } from "../../services/path/common/pathService.service.js";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+export declare class BoundModelReferenceCollection {
+    private readonly _extUri;
+    private readonly _maxAge;
+    private readonly _maxLength;
+    private readonly _maxSize;
+    private _data;
+    private _length;
+    constructor(_extUri: IExtUri, _maxAge?: number, // auto-dispse by age
+    _maxLength?: number, // auto-dispose by total length
+    _maxSize?: number);
+    dispose(): void;
+    remove(uri: URI): void;
+    add(uri: URI, ref: IReference<unknown>, length?: number): void;
+    private _cleanup;
+}
+export declare class MainThreadDocuments extends Disposable implements MainThreadDocumentsShape {
+    private readonly _modelService;
+    private readonly _textFileService;
+    private readonly _fileService;
+    private readonly _textModelResolverService;
+    private readonly _environmentService;
+    private readonly _uriIdentityService;
+    private readonly _pathService;
+    private _onIsCaughtUpWithContentChanges;
+    readonly onIsCaughtUpWithContentChanges: Event<URI>;
+    private readonly _proxy;
+    private readonly _modelTrackers;
+    private readonly _modelReferenceCollection;
+    constructor(extHostContext: IExtHostContext, _modelService: IModelService, _textFileService: ITextFileService, _fileService: IFileService, _textModelResolverService: ITextModelService, _environmentService: IWorkbenchEnvironmentService, _uriIdentityService: IUriIdentityService, workingCopyFileService: IWorkingCopyFileService, _pathService: IPathService);
+    dispose(): void;
+    isCaughtUpWithContentChanges(resource: URI): boolean;
+    private _shouldHandleFileEvent;
+    handleModelAdded(model: ITextModel): void;
+    private _onModelModeChanged;
+    handleModelRemoved(modelUrl: URI): void;
+    $trySaveDocument(uri: UriComponents): Promise<boolean>;
+    $tryOpenDocument(uriData: UriComponents, options?: {
+        encoding?: string;
+    }): Promise<URI>;
+    $tryCreateDocument(options?: {
+        language?: string;
+        content?: string;
+        encoding?: string;
+    }): Promise<URI>;
+    private _handleAsResourceInput;
+    private _handleUntitledScheme;
+    private _doCreateUntitled;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadDocuments.js

@@ -0,0 +1,305 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { toErrorMessage } from '../../../base/common/errorMessage.js';
+import { dispose, Disposable } from '../../../base/common/lifecycle.js';
+import { Schemas } from '../../../base/common/network.js';
+import { URI } from '../../../base/common/uri.js';
+import { shouldSynchronizeModel } from '../../../editor/common/model.js';
+import { IModelService } from '../../../editor/common/services/model.service.js';
+import { ITextModelService } from '../../../editor/common/services/resolverService.service.js';
+import { FileOperation } from '../../../platform/files/common/files.js';
+import { IFileService } from '../../../platform/files/common/files.service.js';
+import { ExtHostContext } from '../common/extHost.protocol.js';
+import { TextFileResolveReason, EncodingMode } from '../../services/textfile/common/textfiles.js';
+import { ITextFileService } from '../../services/textfile/common/textfiles.service.js';
+import { IWorkbenchEnvironmentService } from '../../services/environment/common/environmentService.service.js';
+import { extUri, toLocalResource } from '../../../base/common/resources.js';
+import { IWorkingCopyFileService } from '../../services/workingCopy/common/workingCopyFileService.service.js';
+import { IUriIdentityService } from '../../../platform/uriIdentity/common/uriIdentity.service.js';
+import { Emitter, Event } from '../../../base/common/event.js';
+import { IPathService } from '../../services/path/common/pathService.service.js';
+import { ResourceMap } from '../../../base/common/map.js';
+import { onUnexpectedError, ErrorNoTelemetry } from '../../../base/common/errors.js';
+
+class BoundModelReferenceCollection {
+    constructor(
+        _extUri,
+        _maxAge = 1000 * 60 * 3,
+        _maxLength = 1024 * 1024 * 80,
+        _maxSize = 50
+    ) {
+        this._extUri = _extUri;
+        this._maxAge = _maxAge;
+        this._maxLength = _maxLength;
+        this._maxSize = _maxSize;
+        this._data = ( new Array());
+        this._length = 0;
+    }
+    dispose() {
+        this._data = dispose(this._data);
+    }
+    remove(uri) {
+        for (const entry of [...this._data] ) {
+            if (this._extUri.isEqualOrParent(entry.uri, uri)) {
+                entry.dispose();
+            }
+        }
+    }
+    add(uri, ref, length = 0) {
+        const dispose = () => {
+            const idx = this._data.indexOf(entry);
+            if (idx >= 0) {
+                this._length -= length;
+                ref.dispose();
+                clearTimeout(handle);
+                this._data.splice(idx, 1);
+            }
+        };
+        const handle = setTimeout(dispose, this._maxAge);
+        const entry = {
+            uri,
+            length,
+            dispose
+        };
+        this._data.push(entry);
+        this._length += length;
+        this._cleanup();
+    }
+    _cleanup() {
+        while (this._length > this._maxLength) {
+            this._data[0].dispose();
+        }
+        const extraSize = Math.ceil(this._maxSize * 1.2);
+        if (this._data.length >= extraSize) {
+            dispose(this._data.slice(0, extraSize - this._maxSize));
+        }
+    }
+}
+class ModelTracker extends Disposable {
+    constructor(_model, _onIsCaughtUpWithContentChanges, _proxy, _textFileService) {
+        super();
+        this._model = _model;
+        this._onIsCaughtUpWithContentChanges = _onIsCaughtUpWithContentChanges;
+        this._proxy = _proxy;
+        this._textFileService = _textFileService;
+        this._knownVersionId = this._model.getVersionId();
+        this._store.add(this._model.onDidChangeContent(e => {
+            this._knownVersionId = e.versionId;
+            if (e.detailedReasonsChangeLengths.length !== 1) {
+                onUnexpectedError(( new Error(`Unexpected reasons: ${( e.detailedReasons.map(r => ( r.toString())))}`)));
+            }
+            const evt = {
+                changes: e.changes,
+                isEolChange: e.isEolChange,
+                isUndoing: e.isUndoing,
+                isRedoing: e.isRedoing,
+                isFlush: e.isFlush,
+                eol: e.eol,
+                versionId: e.versionId,
+                detailedReason: e.detailedReasons[0].metadata
+            };
+            this._proxy.$acceptModelChanged(this._model.uri, evt, this._textFileService.isDirty(this._model.uri));
+            if (this.isCaughtUpWithContentChanges()) {
+                this._onIsCaughtUpWithContentChanges.fire(this._model.uri);
+            }
+        }));
+    }
+    isCaughtUpWithContentChanges() {
+        return (this._model.getVersionId() === this._knownVersionId);
+    }
+}
+let MainThreadDocuments = class MainThreadDocuments extends Disposable {
+    constructor(
+        extHostContext,
+        _modelService,
+        _textFileService,
+        _fileService,
+        _textModelResolverService,
+        _environmentService,
+        _uriIdentityService,
+        workingCopyFileService,
+        _pathService
+    ) {
+        super();
+        this._modelService = _modelService;
+        this._textFileService = _textFileService;
+        this._fileService = _fileService;
+        this._textModelResolverService = _textModelResolverService;
+        this._environmentService = _environmentService;
+        this._uriIdentityService = _uriIdentityService;
+        this._pathService = _pathService;
+        this._onIsCaughtUpWithContentChanges = this._store.add(( new Emitter()));
+        this.onIsCaughtUpWithContentChanges = this._onIsCaughtUpWithContentChanges.event;
+        this._modelTrackers = ( new ResourceMap());
+        this._modelReferenceCollection = this._store.add(( new BoundModelReferenceCollection(_uriIdentityService.extUri)));
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDocuments));
+        this._store.add(_modelService.onModelLanguageChanged(this._onModelModeChanged, this));
+        this._store.add(_textFileService.files.onDidSave(e => {
+            if (this._shouldHandleFileEvent(e.model.resource)) {
+                this._proxy.$acceptModelSaved(e.model.resource);
+            }
+        }));
+        this._store.add(_textFileService.files.onDidChangeDirty(m => {
+            if (this._shouldHandleFileEvent(m.resource)) {
+                this._proxy.$acceptDirtyStateChanged(m.resource, m.isDirty());
+            }
+        }));
+        this._store.add(Event.any(
+            _textFileService.files.onDidChangeEncoding,
+            _textFileService.untitled.onDidChangeEncoding
+        )(m => {
+            if (this._shouldHandleFileEvent(m.resource)) {
+                const encoding = m.getEncoding();
+                if (encoding) {
+                    this._proxy.$acceptEncodingChanged(m.resource, encoding);
+                }
+            }
+        }));
+        this._store.add(workingCopyFileService.onDidRunWorkingCopyFileOperation(e => {
+            const isMove = e.operation === FileOperation.MOVE;
+            if (isMove || e.operation === FileOperation.DELETE) {
+                for (const pair of e.files) {
+                    const removed = isMove ? pair.source : pair.target;
+                    if (removed) {
+                        this._modelReferenceCollection.remove(removed);
+                    }
+                }
+            }
+        }));
+    }
+    dispose() {
+        dispose(( this._modelTrackers.values()));
+        this._modelTrackers.clear();
+        super.dispose();
+    }
+    isCaughtUpWithContentChanges(resource) {
+        const tracker = this._modelTrackers.get(resource);
+        if (tracker) {
+            return tracker.isCaughtUpWithContentChanges();
+        }
+        return true;
+    }
+    _shouldHandleFileEvent(resource) {
+        const model = this._modelService.getModel(resource);
+        return !!model && shouldSynchronizeModel(model);
+    }
+    handleModelAdded(model) {
+        if (!shouldSynchronizeModel(model)) {
+            return;
+        }
+        this._modelTrackers.set(model.uri, ( new ModelTracker(
+            model,
+            this._onIsCaughtUpWithContentChanges,
+            this._proxy,
+            this._textFileService
+        )));
+    }
+    _onModelModeChanged(event) {
+        const {
+            model
+        } = event;
+        if (!( this._modelTrackers.has(model.uri))) {
+            return;
+        }
+        this._proxy.$acceptModelLanguageChanged(model.uri, model.getLanguageId());
+    }
+    handleModelRemoved(modelUrl) {
+        if (!( this._modelTrackers.has(modelUrl))) {
+            return;
+        }
+        this._modelTrackers.get(modelUrl).dispose();
+        this._modelTrackers.delete(modelUrl);
+    }
+    async $trySaveDocument(uri) {
+        const target = await this._textFileService.save(URI.revive(uri));
+        return Boolean(target);
+    }
+    async $tryOpenDocument(uriData, options) {
+        const inputUri = URI.revive(uriData);
+        if (!inputUri.scheme || !(inputUri.fsPath || inputUri.authority)) {
+            throw ( new ErrorNoTelemetry(`Invalid uri. Scheme and authority or path must be set.`));
+        }
+        const canonicalUri = this._uriIdentityService.asCanonicalUri(inputUri);
+        let promise;
+        switch (canonicalUri.scheme) {
+        case Schemas.untitled:
+            promise = this._handleUntitledScheme(canonicalUri, options);
+            break;
+        case Schemas.file:
+        default:
+            promise = this._handleAsResourceInput(canonicalUri, options);
+            break;
+        }
+        let documentUri;
+        try {
+            documentUri = await promise;
+        } catch (err) {
+            throw ( new ErrorNoTelemetry(`cannot open ${( canonicalUri.toString())}. Detail: ${toErrorMessage(err)}`));
+        }
+        if (!documentUri) {
+            throw ( new ErrorNoTelemetry(`cannot open ${( canonicalUri.toString())}`));
+        } else if (!extUri.isEqual(documentUri, canonicalUri)) {
+            throw ( new ErrorNoTelemetry(`cannot open ${( canonicalUri.toString())}. Detail: Actual document opened as ${( documentUri.toString())}`));
+        } else if (!( this._modelTrackers.has(canonicalUri))) {
+            throw ( new ErrorNoTelemetry(`cannot open ${( canonicalUri.toString())}. Detail: Files above 50MB cannot be synchronized with extensions.`));
+        } else {
+            return canonicalUri;
+        }
+    }
+    $tryCreateDocument(options) {
+        return this._doCreateUntitled(undefined, options);
+    }
+    async _handleAsResourceInput(uri, options) {
+        if (options?.encoding) {
+            const model = await this._textFileService.files.resolve(uri, {
+                encoding: options.encoding,
+                reason: TextFileResolveReason.REFERENCE
+            });
+            if (model.isDirty()) {
+                throw ( new ErrorNoTelemetry(
+                    `Cannot re-open a dirty text document with different encoding. Save it first.`
+                ));
+            }
+            await model.setEncoding(options.encoding, EncodingMode.Decode);
+        }
+        const ref = await this._textModelResolverService.createModelReference(uri);
+        this._modelReferenceCollection.add(uri, ref, ref.object.textEditorModel.getValueLength());
+        return ref.object.textEditorModel.uri;
+    }
+    async _handleUntitledScheme(uri, options) {
+        const asLocalUri = toLocalResource(
+            uri,
+            this._environmentService.remoteAuthority,
+            this._pathService.defaultUriScheme
+        );
+        const exists = await this._fileService.exists(asLocalUri);
+        if (exists) {
+            return Promise.reject(( new Error("file already exists")));
+        }
+        return await this._doCreateUntitled(Boolean(uri.path) ? uri : undefined, options);
+    }
+    async _doCreateUntitled(associatedResource, options) {
+        const model = this._textFileService.untitled.create({
+            associatedResource,
+            languageId: options?.language,
+            initialValue: options?.content,
+            encoding: options?.encoding
+        });
+        if (options?.encoding) {
+            await model.setEncoding(options.encoding);
+        }
+        const resource = model.resource;
+        const ref = await this._textModelResolverService.createModelReference(resource);
+        if (!( this._modelTrackers.has(resource))) {
+            ref.dispose();
+            throw ( new Error(`expected URI ${( resource.toString())} to have come to LIFE`));
+        }
+        this._modelReferenceCollection.add(resource, ref, ref.object.textEditorModel.getValueLength());
+        Event.once(model.onDidRevert)(() => this._modelReferenceCollection.remove(resource));
+        this._proxy.$acceptDirtyStateChanged(resource, true);
+        return resource;
+    }
+};
+MainThreadDocuments = ( __decorate([( __param(1, IModelService)), ( __param(2, ITextFileService)), ( __param(3, IFileService)), ( __param(4, ITextModelService)), ( __param(5, IWorkbenchEnvironmentService)), ( __param(6, IUriIdentityService)), ( __param(7, IWorkingCopyFileService)), ( __param(8, IPathService))], MainThreadDocuments));
+
+export { BoundModelReferenceCollection, MainThreadDocuments };