@codingame/monaco-editor-wrapper 4.0.0-next.3 → 4.0.0

package/dist/node_modules/@codingame/monaco-vscode-files-service-override/vscode/src/vs/workbench/services/textfile/common/textFileEditorModelManager.js

@@ -0,0 +1,404 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { TextFileEditorModel } from 'vscode/vscode/vs/workbench/services/textfile/common/textFileEditorModel';
+import { Disposable, DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { ResourceQueue, Promises } from 'vscode/vscode/vs/base/common/async';
+import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
+import { TextFileSaveParticipant } from './textFileSaveParticipant.js';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { joinPath, extname } from 'vscode/vscode/vs/base/common/resources';
+import { createTextBufferFactoryFromSnapshot } from 'vscode/vscode/vs/editor/common/model/textModel';
+import { PLAINTEXT_LANGUAGE_ID, PLAINTEXT_EXTENSION } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+
+let TextFileEditorModelManager = class TextFileEditorModelManager extends Disposable {
+    get models() {
+        return [...( this.mapResourceToModel.values())];
+    }
+    constructor(instantiationService, fileService, notificationService, workingCopyFileService, uriIdentityService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.fileService = fileService;
+        this.notificationService = notificationService;
+        this.workingCopyFileService = workingCopyFileService;
+        this.uriIdentityService = uriIdentityService;
+        this._onDidCreate = this._register(( new Emitter()));
+        this.onDidCreate = this._onDidCreate.event;
+        this._onDidResolve = this._register(( new Emitter()));
+        this.onDidResolve = this._onDidResolve.event;
+        this._onDidRemove = this._register(( new Emitter()));
+        this.onDidRemove = this._onDidRemove.event;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this._onDidSaveError = this._register(( new Emitter()));
+        this.onDidSaveError = this._onDidSaveError.event;
+        this._onDidSave = this._register(( new Emitter()));
+        this.onDidSave = this._onDidSave.event;
+        this._onDidRevert = this._register(( new Emitter()));
+        this.onDidRevert = this._onDidRevert.event;
+        this._onDidChangeEncoding = this._register(( new Emitter()));
+        this.onDidChangeEncoding = this._onDidChangeEncoding.event;
+        this.mapResourceToModel = ( new ResourceMap());
+        this.mapResourceToModelListeners = ( new ResourceMap());
+        this.mapResourceToDisposeListener = ( new ResourceMap());
+        this.mapResourceToPendingModelResolvers = ( new ResourceMap());
+        this.modelResolveQueue = this._register(( new ResourceQueue()));
+        this.saveErrorHandler = (() => {
+            const notificationService = this.notificationService;
+            return {
+                onSaveError(error, model) {
+                    notificationService.error(( localizeWithPath(
+                        'vs/workbench/services/textfile/common/textFileEditorModelManager',
+                        { key: 'genericSaveError', comment: ['{0} is the resource that failed to save and {1} the error message'] },
+                        "Failed to save '{0}': {1}",
+                        model.name,
+                        toErrorMessage(error, false)
+                    )));
+                }
+            };
+        })();
+        this.mapCorrelationIdToModelsToRestore = ( new Map());
+        this.saveParticipants = this._register(this.instantiationService.createInstance(TextFileSaveParticipant));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
+        this._register(this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onDidChangeFileSystemProviderCapabilities(e)));
+        this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onDidChangeFileSystemProviderRegistrations(e)));
+        this._register(this.workingCopyFileService.onWillRunWorkingCopyFileOperation(e => this.onWillRunWorkingCopyFileOperation(e)));
+        this._register(this.workingCopyFileService.onDidFailWorkingCopyFileOperation(e => this.onDidFailWorkingCopyFileOperation(e)));
+        this._register(this.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => this.onDidRunWorkingCopyFileOperation(e)));
+    }
+    onDidFilesChange(e) {
+        for (const model of this.models) {
+            if (model.isDirty()) {
+                continue;
+            }
+            if (e.contains(model.resource, 0 , 1 )) {
+                this.queueModelReload(model);
+            }
+        }
+    }
+    onDidChangeFileSystemProviderCapabilities(e) {
+        this.queueModelReloads(e.scheme);
+    }
+    onDidChangeFileSystemProviderRegistrations(e) {
+        if (!e.added) {
+            return;
+        }
+        this.queueModelReloads(e.scheme);
+    }
+    queueModelReloads(scheme) {
+        for (const model of this.models) {
+            if (model.isDirty()) {
+                continue;
+            }
+            if (scheme === model.resource.scheme) {
+                this.queueModelReload(model);
+            }
+        }
+    }
+    queueModelReload(model) {
+        const queue = this.modelResolveQueue.queueFor(model.resource);
+        if (queue.size <= 1) {
+            queue.queue(async () => {
+                try {
+                    await this.reload(model);
+                }
+                catch (error) {
+                    onUnexpectedError(error);
+                }
+            });
+        }
+    }
+    onWillRunWorkingCopyFileOperation(e) {
+        if (e.operation === 2  || e.operation === 3 ) {
+            const modelsToRestore = [];
+            for (const { source, target } of e.files) {
+                if (source) {
+                    if (this.uriIdentityService.extUri.isEqual(source, target)) {
+                        continue;
+                    }
+                    const sourceModels = [];
+                    for (const model of this.models) {
+                        if (this.uriIdentityService.extUri.isEqualOrParent(model.resource, source)) {
+                            sourceModels.push(model);
+                        }
+                    }
+                    for (const sourceModel of sourceModels) {
+                        const sourceModelResource = sourceModel.resource;
+                        let targetModelResource;
+                        if (this.uriIdentityService.extUri.isEqual(sourceModelResource, source)) {
+                            targetModelResource = target;
+                        }
+                        else {
+                            targetModelResource = joinPath(target, sourceModelResource.path.substr(source.path.length + 1));
+                        }
+                        modelsToRestore.push({
+                            source: sourceModelResource,
+                            target: targetModelResource,
+                            languageId: sourceModel.getLanguageId(),
+                            encoding: sourceModel.getEncoding(),
+                            snapshot: sourceModel.isDirty() ? sourceModel.createSnapshot() : undefined
+                        });
+                    }
+                }
+            }
+            this.mapCorrelationIdToModelsToRestore.set(e.correlationId, modelsToRestore);
+        }
+    }
+    onDidFailWorkingCopyFileOperation(e) {
+        if (((e.operation === 2  || e.operation === 3) )) {
+            const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
+            if (modelsToRestore) {
+                this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
+                modelsToRestore.forEach(model => {
+                    if (model.snapshot) {
+                        this.get(model.source)?.setDirty(true);
+                    }
+                });
+            }
+        }
+    }
+    onDidRunWorkingCopyFileOperation(e) {
+        switch (e.operation) {
+            case 0 :
+                e.waitUntil((async () => {
+                    for (const { target } of e.files) {
+                        const model = this.get(target);
+                        if (model && !model.isDisposed()) {
+                            await model.revert();
+                        }
+                    }
+                })());
+                break;
+            case 2 :
+            case 3 :
+                e.waitUntil((async () => {
+                    const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
+                    if (modelsToRestore) {
+                        this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
+                        await Promises.settled(( modelsToRestore.map(async (modelToRestore) => {
+                            const restoredModel = await this.resolve(modelToRestore.target, {
+                                reload: { async: false },
+                                contents: modelToRestore.snapshot ? createTextBufferFactoryFromSnapshot(modelToRestore.snapshot) : undefined,
+                                encoding: modelToRestore.encoding
+                            });
+                            if (modelToRestore.languageId &&
+                                modelToRestore.languageId !== PLAINTEXT_LANGUAGE_ID &&
+                                restoredModel.getLanguageId() === PLAINTEXT_LANGUAGE_ID &&
+                                extname(modelToRestore.target) !== PLAINTEXT_EXTENSION) {
+                                restoredModel.updateTextEditorModel(undefined, modelToRestore.languageId);
+                            }
+                        })));
+                    }
+                })());
+                break;
+        }
+    }
+    get(resource) {
+        return this.mapResourceToModel.get(resource);
+    }
+    has(resource) {
+        return ( this.mapResourceToModel.has(resource));
+    }
+    async reload(model) {
+        await this.joinPendingResolves(model.resource);
+        if (model.isDirty() || model.isDisposed() || !( this.has(model.resource))) {
+            return;
+        }
+        await this.doResolve(model, { reload: { async: false } });
+    }
+    async resolve(resource, options) {
+        const pendingResolve = this.joinPendingResolves(resource);
+        if (pendingResolve) {
+            await pendingResolve;
+        }
+        return this.doResolve(resource, options);
+    }
+    async doResolve(resourceOrModel, options) {
+        let model;
+        let resource;
+        if (URI.isUri(resourceOrModel)) {
+            resource = resourceOrModel;
+            model = this.get(resource);
+        }
+        else {
+            resource = resourceOrModel.resource;
+            model = resourceOrModel;
+        }
+        let modelResolve;
+        let didCreateModel = false;
+        if (model) {
+            if (options?.contents) {
+                modelResolve = model.resolve(options);
+            }
+            else if (options?.reload) {
+                if (options.reload.async) {
+                    modelResolve = Promise.resolve();
+                    (async () => {
+                        try {
+                            await model.resolve(options);
+                        }
+                        catch (error) {
+                            onUnexpectedError(error);
+                        }
+                    })();
+                }
+                else {
+                    modelResolve = model.resolve(options);
+                }
+            }
+            else {
+                modelResolve = Promise.resolve();
+            }
+        }
+        else {
+            didCreateModel = true;
+            const newModel = model = this.instantiationService.createInstance(TextFileEditorModel, resource, options ? options.encoding : undefined, options ? options.languageId : undefined);
+            modelResolve = model.resolve(options);
+            this.registerModel(newModel);
+        }
+        this.mapResourceToPendingModelResolvers.set(resource, modelResolve);
+        this.add(resource, model);
+        if (didCreateModel) {
+            this._onDidCreate.fire(model);
+            if (model.isDirty()) {
+                this._onDidChangeDirty.fire(model);
+            }
+        }
+        try {
+            await modelResolve;
+        }
+        catch (error) {
+            if (didCreateModel) {
+                model.dispose();
+            }
+            throw error;
+        }
+        finally {
+            this.mapResourceToPendingModelResolvers.delete(resource);
+        }
+        if (options?.languageId) {
+            model.setLanguageId(options.languageId);
+        }
+        if (didCreateModel && model.isDirty()) {
+            this._onDidChangeDirty.fire(model);
+        }
+        return model;
+    }
+    joinPendingResolves(resource) {
+        const pendingModelResolve = this.mapResourceToPendingModelResolvers.get(resource);
+        if (!pendingModelResolve) {
+            return;
+        }
+        return this.doJoinPendingResolves(resource);
+    }
+    async doJoinPendingResolves(resource) {
+        let currentModelCopyResolve;
+        while (( this.mapResourceToPendingModelResolvers.has(resource))) {
+            const nextPendingModelResolve = this.mapResourceToPendingModelResolvers.get(resource);
+            if (nextPendingModelResolve === currentModelCopyResolve) {
+                return;
+            }
+            currentModelCopyResolve = nextPendingModelResolve;
+            try {
+                await nextPendingModelResolve;
+            }
+            catch (error) {
+            }
+        }
+    }
+    registerModel(model) {
+        const modelListeners = ( new DisposableStore());
+        modelListeners.add(model.onDidResolve(reason => this._onDidResolve.fire({ model, reason })));
+        modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire(model)));
+        modelListeners.add(model.onDidChangeReadonly(() => this._onDidChangeReadonly.fire(model)));
+        modelListeners.add(model.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire(model)));
+        modelListeners.add(model.onDidSaveError(() => this._onDidSaveError.fire(model)));
+        modelListeners.add(model.onDidSave(e => this._onDidSave.fire({ model, ...e })));
+        modelListeners.add(model.onDidRevert(() => this._onDidRevert.fire(model)));
+        modelListeners.add(model.onDidChangeEncoding(() => this._onDidChangeEncoding.fire(model)));
+        this.mapResourceToModelListeners.set(model.resource, modelListeners);
+    }
+    add(resource, model) {
+        const knownModel = this.mapResourceToModel.get(resource);
+        if (knownModel === model) {
+            return;
+        }
+        const disposeListener = this.mapResourceToDisposeListener.get(resource);
+        disposeListener?.dispose();
+        this.mapResourceToModel.set(resource, model);
+        this.mapResourceToDisposeListener.set(resource, model.onWillDispose(() => this.remove(resource)));
+    }
+    remove(resource) {
+        const removed = this.mapResourceToModel.delete(resource);
+        const disposeListener = this.mapResourceToDisposeListener.get(resource);
+        if (disposeListener) {
+            dispose(disposeListener);
+            this.mapResourceToDisposeListener.delete(resource);
+        }
+        const modelListener = this.mapResourceToModelListeners.get(resource);
+        if (modelListener) {
+            dispose(modelListener);
+            this.mapResourceToModelListeners.delete(resource);
+        }
+        if (removed) {
+            this._onDidRemove.fire(resource);
+        }
+    }
+    addSaveParticipant(participant) {
+        return this.saveParticipants.addSaveParticipant(participant);
+    }
+    runSaveParticipants(model, context, token) {
+        return this.saveParticipants.participate(model, context, token);
+    }
+    canDispose(model) {
+        if (model.isDisposed() ||
+            (!( this.mapResourceToPendingModelResolvers.has(model.resource)) && !model.isDirty())) {
+            return true;
+        }
+        return this.doCanDispose(model);
+    }
+    async doCanDispose(model) {
+        const pendingResolve = this.joinPendingResolves(model.resource);
+        if (pendingResolve) {
+            await pendingResolve;
+            return this.canDispose(model);
+        }
+        if (model.isDirty()) {
+            await Event.toPromise(model.onDidChangeDirty);
+            return this.canDispose(model);
+        }
+        return true;
+    }
+    dispose() {
+        super.dispose();
+        this.mapResourceToModel.clear();
+        this.mapResourceToPendingModelResolvers.clear();
+        dispose(( this.mapResourceToDisposeListener.values()));
+        this.mapResourceToDisposeListener.clear();
+        dispose(( this.mapResourceToModelListeners.values()));
+        this.mapResourceToModelListeners.clear();
+    }
+};
+TextFileEditorModelManager = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IFileService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IWorkingCopyFileService)),
+    ( __param(4, IUriIdentityService))
+], TextFileEditorModelManager));
+
+export { TextFileEditorModelManager };

package/dist/node_modules/@codingame/monaco-vscode-files-service-override/vscode/src/vs/workbench/services/textfile/common/textFileSaveParticipant.js

@@ -0,0 +1,64 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { raceCancellation } from 'vscode/vscode/vs/base/common/async';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
+import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { insert } from 'vscode/vscode/vs/base/common/arrays';
+
+let TextFileSaveParticipant = class TextFileSaveParticipant extends Disposable {
+    constructor(progressService, logService) {
+        super();
+        this.progressService = progressService;
+        this.logService = logService;
+        this.saveParticipants = [];
+    }
+    addSaveParticipant(participant) {
+        const remove = insert(this.saveParticipants, participant);
+        return toDisposable(() => remove());
+    }
+    participate(model, context, token) {
+        const cts = ( new CancellationTokenSource(token));
+        return this.progressService.withProgress({
+            title: ( localizeWithPath(
+                'vs/workbench/services/textfile/common/textFileSaveParticipant',
+                'saveParticipants',
+                "Saving '{0}'",
+                model.name
+            )),
+            location: 15 ,
+            cancellable: true,
+            delay: model.isDirty() ? 3000 : 5000
+        }, async (progress) => {
+            model.textEditorModel?.pushStackElement();
+            for (const saveParticipant of this.saveParticipants) {
+                if (cts.token.isCancellationRequested || !model.textEditorModel ) {
+                    break;
+                }
+                try {
+                    const promise = saveParticipant.participate(model, context, progress, cts.token);
+                    await raceCancellation(promise, cts.token);
+                }
+                catch (err) {
+                    this.logService.error(err);
+                }
+            }
+            model.textEditorModel?.pushStackElement();
+        }, () => {
+            cts.cancel();
+        }).finally(() => {
+            cts.dispose();
+        });
+    }
+    dispose() {
+        this.saveParticipants.splice(0, this.saveParticipants.length);
+        super.dispose();
+    }
+};
+TextFileSaveParticipant = ( __decorate([
+    ( __param(0, IProgressService)),
+    ( __param(1, ILogService))
+], TextFileSaveParticipant));
+
+export { TextFileSaveParticipant };

package/dist/node_modules/monaco-vim/lib/cm_adapter.js

@@ -964,7 +964,7 @@ import require$$1 from '../../../_virtual/shiftCommand.js';
 	              return false;
 	            }
 	          } else {
-	            var _pos2 = lastSearch ? model.getPositionAt(model.getOffsetAt(lastSearch.getStartPosition()) + 1) : monacoPos;
+	            var _pos2 = lastSearch ? model.getPositionAt(model.getOffsetAt(lastSearch.getEndPosition()) + 1) : monacoPos;
 
 	            match = model.findNextMatch(query, _pos2, isRegex, matchCase);
 
@@ -994,8 +994,12 @@ import require$$1 from '../../../_virtual/shiftCommand.js';
 	              range: lastSearch,
 	              text: text,
 	              forceMoveMarkers: true
-	            }]);
-	            lastSearch.setEndPosition(editor.getPosition());
+	            }], function (edits) {
+	              var _edits$0$range = edits[0].range,
+	                  endLineNumber = _edits$0$range.endLineNumber,
+	                  endColumn = _edits$0$range.endColumn;
+	              lastSearch = lastSearch.setEndPosition(endLineNumber, endColumn);
+	            });
 	            editor.setPosition(lastSearch.getStartPosition());
 	          }
 	        }

package/dist/services.d.ts

@@ -1,7 +1,9 @@
 import * as monaco from 'monaco-editor';
 import EditorOpenHandlerRegistry from './tools/EditorOpenHandlerRegistry';
-import 'vscode/ext-hosts/all';
+import 'vscode/localExtensionHost';
 declare const editorOpenHandlerRegistry: EditorOpenHandlerRegistry;
+export declare function setUseGlobalPicker(useGlobalPicker?: boolean): void;
+export declare function useGlobalPicker(): boolean;
 export declare function registerServices(newServices: monaco.editor.IEditorOverrideServices): void;
 export declare function initialize(): Promise<void>;
 export { editorOpenHandlerRegistry };

package/dist/services.js

@@ -1,42 +1,72 @@
-import getModelServiceOverride from 'vscode/service-override/model';
-import getDialogsServiceOverride from 'vscode/service-override/dialogs';
-import getConfigurationServiceOverride from 'vscode/service-override/configuration';
-import getKeybindingsServiceOverride from 'vscode/service-override/keybindings';
-import getTextmateServiceOverride from 'vscode/service-override/textmate';
-import getThemeServiceOverride from 'vscode/service-override/theme';
-import getLanguagesServiceOverride from 'vscode/service-override/languages';
-import getAudioCueServiceOverride from 'vscode/service-override/audioCue';
-import getPreferencesServiceOverride from 'vscode/service-override/preferences';
-import getSnippetServiceOverride from 'vscode/service-override/snippets';
-import getQuickAccessServiceOverride from 'vscode/service-override/quickaccess';
-import getAccessibilityServiceOverride from 'vscode/service-override/accessibility';
-import getEditorServiceOverride from 'vscode/service-override/editor';
+import getExtensionServiceOverride from '@codingame/monaco-vscode-extensions-service-override';
+import getModelServiceOverride from '@codingame/monaco-vscode-model-service-override';
+import getDialogsServiceOverride from '@codingame/monaco-vscode-dialogs-service-override';
+import getConfigurationServiceOverride from '@codingame/monaco-vscode-configuration-service-override';
+import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
+import getTextmateServiceOverride from '@codingame/monaco-vscode-textmate-service-override';
+import getThemeServiceOverride from '@codingame/monaco-vscode-theme-service-override';
+import getLanguagesServiceOverride from '@codingame/monaco-vscode-languages-service-override';
+import getAudioCueServiceOverride from '@codingame/monaco-vscode-audio-cue-service-override';
+import getPreferencesServiceOverride from '@codingame/monaco-vscode-preferences-service-override';
+import getSnippetServiceOverride from '@codingame/monaco-vscode-snippets-service-override';
+import getAccessibilityServiceOverride from '@codingame/monaco-vscode-accessibility-service-override';
+import getLanguageDetectionWorkerServiceOverride from '@codingame/monaco-vscode-language-detection-worker-service-override';
+import getEditorServiceOverride from '@codingame/monaco-vscode-editor-service-override';
+import getStorageServiceOverride from '@codingame/monaco-vscode-storage-service-override';
+import getLifecycleServiceOverride from '@codingame/monaco-vscode-lifecycle-service-override';
+import getQuickAccessServiceOverride from '@codingame/monaco-vscode-quickaccess-service-override';
+import getLogServiceOverride from '@codingame/monaco-vscode-log-service-override';
+import getWorkingCopyServiceOverride from '@codingame/monaco-vscode-working-copy-service-override';
 import { initialize as initialize$1, StandaloneServices, ILogService, LogLevel } from 'vscode/services';
-import { initialize as initialize$2 } from 'vscode/extensions';
-import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import * as monaco from 'monaco-editor';
+import { initFile } from './node_modules/@codingame/monaco-vscode-files-service-override/files.js';
+import 'vscode/vscode/vs/platform/files/common/files';
+import 'vscode/vscode/vs/platform/files/browser/htmlFileSystemProvider';
+import 'vscode/vscode/vs/platform/files/common/inMemoryFilesystemProvider';
+import 'vscode/vscode/vs/base/browser/indexedDB';
+import './node_modules/@codingame/monaco-vscode-files-service-override/vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js';
 import EditorOpenHandlerRegistry from './tools/EditorOpenHandlerRegistry.js';
-import 'vscode/ext-hosts/all';
+import 'vscode/localExtensionHost';
 
 const editorOpenHandlerRegistry = new EditorOpenHandlerRegistry();
+let _useGlobalPicker = false;
+function setUseGlobalPicker(useGlobalPicker = true) {
+    _useGlobalPicker = useGlobalPicker;
+}
+function useGlobalPicker() {
+    // should picker and keybindings be global or per-editor
+    return _useGlobalPicker;
+}
 let services = {
+    ...getLogServiceOverride(),
+    ...getExtensionServiceOverride(),
     ...getModelServiceOverride(),
     ...getDialogsServiceOverride(),
-    ...getConfigurationServiceOverride(monaco.Uri.file('/tmp/project')),
-    ...getKeybindingsServiceOverride(),
+    ...getConfigurationServiceOverride(),
+    ...getKeybindingsServiceOverride({
+        shouldUseGlobalKeybindings() {
+            return useGlobalPicker();
+        }
+    }),
     ...getTextmateServiceOverride(),
     ...getThemeServiceOverride(),
     ...getLanguagesServiceOverride(),
     ...getAudioCueServiceOverride(),
     ...getPreferencesServiceOverride(),
     ...getSnippetServiceOverride(),
-    ...getQuickAccessServiceOverride({
-        isKeybindingConfigurationVisible: () => false,
-        shouldUseGlobalPicker: () => false
-    }),
+    ...getLanguageDetectionWorkerServiceOverride(),
     ...getEditorServiceOverride((model, input, sideBySide) => {
         return editorOpenHandlerRegistry.openCodeEditor(model, input, sideBySide);
     }),
-    ...getAccessibilityServiceOverride()
+    ...getAccessibilityServiceOverride(),
+    ...getStorageServiceOverride(),
+    ...getLifecycleServiceOverride(),
+    ...getQuickAccessServiceOverride({
+        shouldUseGlobalPicker() {
+            return useGlobalPicker();
+        }
+    }),
+    ...getWorkingCopyServiceOverride()
 };
 function registerServices(newServices) {
     services = {
@@ -47,9 +77,14 @@ function registerServices(newServices) {
 async function initialize() {
     // wait a short time for the services to be registered
     await new Promise(resolve => setTimeout(resolve, 0));
-    await initialize$1(services);
+    const workspaceFile = monaco.Uri.file('/workspace.code-workspace');
+    await initFile(workspaceFile, JSON.stringify({
+        folders: [{
+                path: '/tmp/project'
+            }]
+    }));
+    await initialize$1(services, undefined, { workspaceProvider: { open: async () => false, workspace: { workspaceUri: workspaceFile }, trusted: true } });
     StandaloneServices.get(ILogService).setLevel(LogLevel.Off);
-    await initialize$2();
 }
 
-export { editorOpenHandlerRegistry, initialize, registerServices };
+export { editorOpenHandlerRegistry, initialize, registerServices, setUseGlobalPicker, useGlobalPicker };

package/dist/tools/EditorOpenHandlerRegistry.d.ts

@@ -1,5 +1,5 @@
 import * as monaco from 'monaco-editor';
-import { OpenEditor, IEditorOptions, IResolvedTextEditorModel } from 'vscode/service-override/editor';
+import { OpenEditor, IEditorOptions, IResolvedTextEditorModel } from '@codingame/monaco-vscode-editor-service-override';
 import { IReference } from 'vscode/monaco';
 export type EditorOpenHandler = (modelRef: IReference<IResolvedTextEditorModel>, input: IEditorOptions | undefined, editor: monaco.editor.ICodeEditor | null, sideBySide?: boolean) => Promise<monaco.editor.ICodeEditor | null>;
 export default class EditorOpenHandlerRegistry {

package/dist/tools/EditorOpenHandlerRegistry.js

@@ -1,7 +1,7 @@
 import { createEditor } from '../monaco.js';
 
 let currentEditor = null;
-async function openNewCodeEditor(modelRef) {
+function openNewCodeEditor(modelRef) {
     if (currentEditor != null && modelRef.object.textEditorModel === currentEditor.model) {
         return currentEditor.editor;
     }
@@ -24,7 +24,7 @@ async function openNewCodeEditor(modelRef) {
     container.appendChild(editorElem);
     document.body.appendChild(container);
     try {
-        const editor = await createEditor(editorElem, {
+        const editor = createEditor(editorElem, {
             model: modelRef.object.textEditorModel,
             readOnly: true,
             automaticLayout: true
@@ -66,7 +66,7 @@ class EditorOpenHandlerRegistry {
                 }
             }
             if (modelEditor == null) {
-                modelEditor = await openNewCodeEditor(modelRef);
+                modelEditor = openNewCodeEditor(modelRef);
                 // Destroy model ref when we close the editor popup
                 const onModelUnmount = () => {
                     modelRef.dispose();

package/dist/tools/FakeWorker.d.ts

@@ -0,0 +1,5 @@
+export declare class Worker {
+    url: string | URL;
+    options?: WorkerOptions | undefined;
+    constructor(url: string | URL, options?: WorkerOptions | undefined);
+}

package/dist/tools/FakeWorker.js

@@ -0,0 +1,8 @@
+class Worker {
+    constructor(url, options) {
+        this.url = url;
+        this.options = options;
+    }
+}
+
+export { Worker };