@codingame/monaco-vscode-api 8.0.3 → 9.0.0

package/vscode/src/vs/editor/browser/controller/textAreaHandler.js

@@ -116,7 +116,7 @@ let TextAreaHandler = class TextAreaHandler extends ViewPart {
         this.textArea.setAttribute('aria-required', options.get(EditorOption.ariaRequired) ? 'true' : 'false');
         this.textArea.setAttribute('tabindex', String(options.get(EditorOption.tabIndex)));
         this.textArea.setAttribute('role', 'textbox');
-        this.textArea.setAttribute('aria-roledescription', ( localize(9833, "editor")));
+        this.textArea.setAttribute('aria-roledescription', ( localize(9877, "editor")));
         this.textArea.setAttribute('aria-multiline', 'true');
         this.textArea.setAttribute('aria-autocomplete', options.get(EditorOption.readOnly) ? 'none' : 'both');
         this._ensureReadOnlyAttribute();
@@ -408,10 +408,10 @@ let TextAreaHandler = class TextAreaHandler extends ViewPart {
             const toggleKeybindingLabel = this._keybindingService.lookupKeybinding('editor.action.toggleScreenReaderAccessibilityMode')?.getAriaLabel();
             const runCommandKeybindingLabel = this._keybindingService.lookupKeybinding('workbench.action.showCommands')?.getAriaLabel();
             const keybindingEditorKeybindingLabel = this._keybindingService.lookupKeybinding('workbench.action.openGlobalKeybindings')?.getAriaLabel();
-            const editorNotAccessibleMessage = ( localize(9834, "The editor is not accessible at this time."));
+            const editorNotAccessibleMessage = ( localize(9878, "The editor is not accessible at this time."));
             if (toggleKeybindingLabel) {
                 return ( localize(
-                    9835,
+                    9879,
                     "{0} To enable screen reader optimized mode, use {1}",
                     editorNotAccessibleMessage,
                     toggleKeybindingLabel
@@ -419,7 +419,7 @@ let TextAreaHandler = class TextAreaHandler extends ViewPart {
             }
             else if (runCommandKeybindingLabel) {
                 return ( localize(
-                    9836,
+                    9880,
                     "{0} To enable screen reader optimized mode, open the quick pick with {1} and run the command Toggle Screen Reader Accessibility Mode, which is currently not triggerable via keyboard.",
                     editorNotAccessibleMessage,
                     runCommandKeybindingLabel
@@ -427,7 +427,7 @@ let TextAreaHandler = class TextAreaHandler extends ViewPart {
             }
             else if (keybindingEditorKeybindingLabel) {
                 return ( localize(
-                    9837,
+                    9881,
                     "{0} Please assign a keybinding for the command Toggle Screen Reader Accessibility Mode by accessing the keybindings editor with {1} and run it.",
                     editorNotAccessibleMessage,
                     keybindingEditorKeybindingLabel

package/vscode/src/vs/editor/browser/coreCommands.js

@@ -861,7 +861,7 @@ var CoreNavigationCommands;
                         type: 'object',
                         properties: {
                             'sticky': {
-                                description: ( localize(1165, "Stick to the end even when going to longer lines")),
+                                description: ( localize(1331, "Stick to the end even when going to longer lines")),
                                 type: 'boolean',
                                 default: false
                             }
@@ -889,7 +889,7 @@ var CoreNavigationCommands;
                         type: 'object',
                         properties: {
                             'sticky': {
-                                description: ( localize(1165, "Stick to the end even when going to longer lines")),
+                                description: ( localize(1331, "Stick to the end even when going to longer lines")),
                                 type: 'boolean',
                                 default: false
                             }
@@ -1431,7 +1431,7 @@ var CoreNavigationCommands;
                 viewModel.getPrimaryCursorState()
             ]);
             viewModel.revealAllCursors(args.source, true);
-            status(( localize(1166, "Removed secondary cursors")));
+            status(( localize(1332, "Removed secondary cursors")));
         }
     }));
     CoreNavigationCommands.RevealLine = registerEditorCommand(new (class extends CoreEditorCommand {

package/vscode/src/vs/editor/browser/editorExtensions.js

@@ -388,12 +388,12 @@ const UndoCommand = registerCommand(( (new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarEditMenu,
             group: '1_do',
-            title: ( localize(550, "&&Undo")),
+            title: ( localize(561, "&&Undo")),
             order: 1
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(551, "Undo")),
+            title: ( localize(562, "Undo")),
             order: 1
         }]
 }))));
@@ -410,12 +410,12 @@ const RedoCommand = registerCommand(( (new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarEditMenu,
             group: '1_do',
-            title: ( localize(552, "&&Redo")),
+            title: ( localize(563, "&&Redo")),
             order: 2
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(553, "Redo")),
+            title: ( localize(564, "Redo")),
             order: 1
         }]
 }))));
@@ -431,12 +431,12 @@ const SelectAllCommand = registerCommand(( (new MultiCommand({
     menuOpts: [{
             menuId: MenuId.MenubarSelectionMenu,
             group: '1_basic',
-            title: ( localize(554, "&&Select All")),
+            title: ( localize(565, "&&Select All")),
             order: 1
         }, {
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(555, "Select All")),
+            title: ( localize(566, "Select All")),
             order: 1
         }]
 }))));

package/vscode/src/vs/editor/browser/services/editorWorkerService.js

@@ -1,8 +1,8 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { timeout, IntervalTimer } from '../../../base/common/async.js';
-import { Disposable, dispose, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
-import { SimpleWorkerClient, logOnceWebWorkerWarning } from '../../../base/common/worker/simpleWorker.js';
-import { DefaultWorkerFactory } from '../../../base/browser/defaultWorkerFactory.js';
+import { timeout } from '../../../base/common/async.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { logOnceWebWorkerWarning } from '../../../base/common/worker/simpleWorker.js';
+import { createWebWorker } from '../../../base/browser/defaultWorkerFactory.js';
 import { Range } from '../../common/core/range.js';
 import { CompletionItemKind } from '../../common/languages.js';
 import { ILanguageConfigurationService } from '../../common/languages/languageConfigurationRegistry.js';
@@ -12,14 +12,15 @@ import { ITextResourceConfigurationService } from '../../common/services/textRes
 import { isNonEmptyArray } from '../../../base/common/arrays.js';
 import { ILogService } from '../../../platform/log/common/log.service.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
-import { canceled, onUnexpectedError } from '../../../base/common/errors.js';
+import { onUnexpectedError, canceled } from '../../../base/common/errors.js';
 import { ILanguageFeaturesService } from '../../common/services/languageFeatures.js';
 import { MovedText } from '../../common/diff/linesDiffComputer.js';
 import { LineRangeMapping, DetailedLineRangeMapping, RangeMapping } from '../../common/diff/rangeMapping.js';
 import { LineRange } from '../../common/core/lineRange.js';
 import { mainWindow } from '../../../base/browser/window.js';
 import { WindowIntervalTimer } from '../../../base/browser/dom.js';
-const STOP_SYNC_MODEL_DELTA_TIME_MS = 60 * 1000;
+import { WorkerTextModelSyncClient } from '../../common/services/textModelSync/textModelSync.impl.js';
+import { EditorWorkerHost } from '../../common/services/editorWorkerHost.js';
 const STOP_WORKER_DELTA_TIME_MS = 5 * 60 * 1000;
 function canSyncModel(modelService, resource) {
     const model = modelService.getModel(resource);
@@ -32,26 +33,27 @@ function canSyncModel(modelService, resource) {
     return true;
 }
 let EditorWorkerService = class EditorWorkerService extends Disposable {
-    constructor(modelService, configurationService, logService, languageConfigurationService, languageFeaturesService) {
+    constructor(workerDescriptor, modelService, configurationService, logService, _languageConfigurationService, languageFeaturesService) {
         super();
+        this._languageConfigurationService = _languageConfigurationService;
         this._modelService = modelService;
-        this._workerManager = this._register(( new WorkerManager(this._modelService, languageConfigurationService)));
+        this._workerManager = this._register(( new WorkerManager(workerDescriptor, this._modelService)));
         this._logService = logService;
         this._register(languageFeaturesService.linkProvider.register({ language: '*', hasAccessToAllModels: true }, {
-            provideLinks: (model, token) => {
+            provideLinks: async (model, token) => {
                 if (!canSyncModel(this._modelService, model.uri)) {
                     return Promise.resolve({ links: [] });
                 }
-                return this._workerManager.withWorker().then(client => client.computeLinks(model.uri)).then(links => {
-                    return links && { links };
-                });
+                const worker = await this._workerWithResources([model.uri]);
+                const links = await worker.$computeLinks(( model.uri.toString()));
+                return links && { links };
             }
         }));
         this._register(languageFeaturesService.completionProvider.register('*', ( new WordBasedCompletionItemProvider(
             this._workerManager,
             configurationService,
             this._modelService,
-            languageConfigurationService
+            this._languageConfigurationService
         ))));
     }
     dispose() {
@@ -60,11 +62,13 @@ let EditorWorkerService = class EditorWorkerService extends Disposable {
     canComputeUnicodeHighlights(uri) {
         return canSyncModel(this._modelService, uri);
     }
-    computedUnicodeHighlights(uri, options, range) {
-        return this._workerManager.withWorker().then(client => client.computedUnicodeHighlights(uri, options, range));
+    async computedUnicodeHighlights(uri, options, range) {
+        const worker = await this._workerWithResources([uri]);
+        return worker.$computeUnicodeHighlights(( uri.toString()), options, range);
     }
     async computeDiff(original, modified, options, algorithm) {
-        const result = await this._workerManager.withWorker().then(client => client.computeDiff(original, modified, options, algorithm));
+        const worker = await this._workerWithResources([original, modified],  true);
+        const result = await worker.$computeDiff(( original.toString()), ( modified.toString()), options, algorithm);
         if (!result) {
             return null;
         }
@@ -82,16 +86,17 @@ let EditorWorkerService = class EditorWorkerService extends Disposable {
     canComputeDirtyDiff(original, modified) {
         return (canSyncModel(this._modelService, original) && canSyncModel(this._modelService, modified));
     }
-    computeDirtyDiff(original, modified, ignoreTrimWhitespace) {
-        return this._workerManager.withWorker().then(client => client.computeDirtyDiff(original, modified, ignoreTrimWhitespace));
+    async computeDirtyDiff(original, modified, ignoreTrimWhitespace) {
+        const worker = await this._workerWithResources([original, modified]);
+        return worker.$computeDirtyDiff(( original.toString()), ( modified.toString()), ignoreTrimWhitespace);
     }
-    computeMoreMinimalEdits(resource, edits, pretty = false) {
+    async computeMoreMinimalEdits(resource, edits, pretty = false) {
         if (isNonEmptyArray(edits)) {
             if (!canSyncModel(this._modelService, resource)) {
                 return Promise.resolve(edits);
             }
             const sw = StopWatch.create();
-            const result = this._workerManager.withWorker().then(client => client.computeMoreMinimalEdits(resource, edits, pretty));
+            const result = this._workerWithResources([resource]).then(worker => worker.$computeMoreMinimalEdits(( resource.toString()), edits, pretty));
             result.finally(() => this._logService.trace('FORMAT#computeMoreMinimalEdits', ( resource.toString(true)), sw.elapsed()));
             return Promise.race([result, timeout(1000).then(() => edits)]);
         }
@@ -105,10 +110,13 @@ let EditorWorkerService = class EditorWorkerService extends Disposable {
                 return Promise.resolve(edits);
             }
             const sw = StopWatch.create();
-            const result = this._workerManager.withWorker().then(client => client.computeHumanReadableDiff(resource, edits, { ignoreTrimWhitespace: false, maxComputationTimeMs: 1000, computeMoves: false, })).catch((err) => {
+            const opts = { ignoreTrimWhitespace: false, maxComputationTimeMs: 1000, computeMoves: false };
+            const result = (this._workerWithResources([resource])
+                .then(worker => worker.$computeHumanReadableDiff(( resource.toString()), edits, opts))
+                .catch((err) => {
                 onUnexpectedError(err);
                 return this.computeMoreMinimalEdits(resource, edits, true);
-            });
+            }));
             result.finally(() => this._logService.trace('FORMAT#computeHumanReadableDiff', ( resource.toString(true)), sw.elapsed()));
             return result;
         }
@@ -119,25 +127,50 @@ let EditorWorkerService = class EditorWorkerService extends Disposable {
     canNavigateValueSet(resource) {
         return (canSyncModel(this._modelService, resource));
     }
-    navigateValueSet(resource, range, up) {
-        return this._workerManager.withWorker().then(client => client.navigateValueSet(resource, range, up));
+    async navigateValueSet(resource, range, up) {
+        const model = this._modelService.getModel(resource);
+        if (!model) {
+            return null;
+        }
+        const wordDefRegExp = this._languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).getWordDefinition();
+        const wordDef = wordDefRegExp.source;
+        const wordDefFlags = wordDefRegExp.flags;
+        const worker = await this._workerWithResources([resource]);
+        return worker.$navigateValueSet(( resource.toString()), range, up, wordDef, wordDefFlags);
     }
     canComputeWordRanges(resource) {
         return canSyncModel(this._modelService, resource);
     }
-    computeWordRanges(resource, range) {
-        return this._workerManager.withWorker().then(client => client.computeWordRanges(resource, range));
+    async computeWordRanges(resource, range) {
+        const model = this._modelService.getModel(resource);
+        if (!model) {
+            return Promise.resolve(null);
+        }
+        const wordDefRegExp = this._languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).getWordDefinition();
+        const wordDef = wordDefRegExp.source;
+        const wordDefFlags = wordDefRegExp.flags;
+        const worker = await this._workerWithResources([resource]);
+        return worker.$computeWordRanges(( resource.toString()), range, wordDef, wordDefFlags);
+    }
+    async findSectionHeaders(uri, options) {
+        const worker = await this._workerWithResources([uri]);
+        return worker.$findSectionHeaders(( uri.toString()), options);
     }
-    findSectionHeaders(uri, options) {
-        return this._workerManager.withWorker().then(client => client.findSectionHeaders(uri, options));
+    async computeDefaultDocumentColors(uri) {
+        const worker = await this._workerWithResources([uri]);
+        return worker.$computeDefaultDocumentColors(( uri.toString()));
+    }
+    async _workerWithResources(resources, forceLargeModels = false) {
+        const worker = await this._workerManager.withWorker();
+        return await worker.workerWithSyncedResources(resources, forceLargeModels);
     }
 };
 EditorWorkerService = ( __decorate([
-    ( __param(0, IModelService)),
-    ( __param(1, ITextResourceConfigurationService)),
-    ( __param(2, ILogService)),
-    ( __param(3, ILanguageConfigurationService)),
-    ( __param(4, ILanguageFeaturesService))
+    ( __param(1, IModelService)),
+    ( __param(2, ITextResourceConfigurationService)),
+    ( __param(3, ILogService)),
+    ( __param(4, ILanguageConfigurationService)),
+    ( __param(5, ILanguageFeaturesService))
 ], EditorWorkerService));
 class WordBasedCompletionItemProvider {
     constructor(workerManager, configurationService, modelService, languageConfigurationService) {
@@ -196,10 +229,10 @@ class WordBasedCompletionItemProvider {
         };
     }
 }
-class WorkerManager extends Disposable {
-    constructor(modelService, languageConfigurationService) {
+let WorkerManager = class WorkerManager extends Disposable {
+    constructor(_workerDescriptor, modelService) {
         super();
-        this.languageConfigurationService = languageConfigurationService;
+        this._workerDescriptor = _workerDescriptor;
         this._modelService = modelService;
         this._editorWorkerClient = null;
         this._lastWorkerUsedTime = (( new Date())).getTime();
@@ -237,123 +270,36 @@ class WorkerManager extends Disposable {
     withWorker() {
         this._lastWorkerUsedTime = (( new Date())).getTime();
         if (!this._editorWorkerClient) {
-            this._editorWorkerClient = ( new EditorWorkerClient(
-                this._modelService,
-                false,
-                'editorWorkerService',
-                this.languageConfigurationService
-            ));
+            this._editorWorkerClient = ( new EditorWorkerClient(this._workerDescriptor, false, this._modelService));
         }
         return Promise.resolve(this._editorWorkerClient);
     }
-}
-class EditorModelManager extends Disposable {
-    constructor(proxy, modelService, keepIdleModels) {
-        super();
-        this._syncedModels = Object.create(null);
-        this._syncedModelsLastUsedTime = Object.create(null);
-        this._proxy = proxy;
-        this._modelService = modelService;
-        if (!keepIdleModels) {
-            const timer = ( new IntervalTimer());
-            timer.cancelAndSet(() => this._checkStopModelSync(), Math.round(STOP_SYNC_MODEL_DELTA_TIME_MS / 2));
-            this._register(timer);
-        }
-    }
-    dispose() {
-        for (const modelUrl in this._syncedModels) {
-            dispose(this._syncedModels[modelUrl]);
-        }
-        this._syncedModels = Object.create(null);
-        this._syncedModelsLastUsedTime = Object.create(null);
-        super.dispose();
-    }
-    ensureSyncedResources(resources, forceLargeModels) {
-        for (const resource of resources) {
-            const resourceStr = ( resource.toString());
-            if (!this._syncedModels[resourceStr]) {
-                this._beginModelSync(resource, forceLargeModels);
-            }
-            if (this._syncedModels[resourceStr]) {
-                this._syncedModelsLastUsedTime[resourceStr] = (( new Date())).getTime();
-            }
-        }
-    }
-    _checkStopModelSync() {
-        const currentTime = (( new Date())).getTime();
-        const toRemove = [];
-        for (const modelUrl in this._syncedModelsLastUsedTime) {
-            const elapsedTime = currentTime - this._syncedModelsLastUsedTime[modelUrl];
-            if (elapsedTime > STOP_SYNC_MODEL_DELTA_TIME_MS) {
-                toRemove.push(modelUrl);
-            }
-        }
-        for (const e of toRemove) {
-            this._stopModelSync(e);
-        }
-    }
-    _beginModelSync(resource, forceLargeModels) {
-        const model = this._modelService.getModel(resource);
-        if (!model) {
-            return;
-        }
-        if (!forceLargeModels && model.isTooLargeForSyncing()) {
-            return;
-        }
-        const modelUrl = ( resource.toString());
-        this._proxy.acceptNewModel({
-            url: ( model.uri.toString()),
-            lines: model.getLinesContent(),
-            EOL: model.getEOL(),
-            versionId: model.getVersionId()
-        });
-        const toDispose = ( new DisposableStore());
-        toDispose.add(model.onDidChangeContent((e) => {
-            this._proxy.acceptModelChanged(( modelUrl.toString()), e);
-        }));
-        toDispose.add(model.onWillDispose(() => {
-            this._stopModelSync(modelUrl);
-        }));
-        toDispose.add(toDisposable(() => {
-            this._proxy.acceptRemovedModel(modelUrl);
-        }));
-        this._syncedModels[modelUrl] = toDispose;
-    }
-    _stopModelSync(modelUrl) {
-        const toDispose = this._syncedModels[modelUrl];
-        delete this._syncedModels[modelUrl];
-        delete this._syncedModelsLastUsedTime[modelUrl];
-        dispose(toDispose);
-    }
-}
+};
+WorkerManager = ( __decorate([
+    ( __param(1, IModelService))
+], WorkerManager));
 class SynchronousWorkerClient {
     constructor(instance) {
         this._instance = instance;
-        this._proxyObj = Promise.resolve(this._instance);
+        this.proxy = this._instance;
     }
     dispose() {
         this._instance.dispose();
     }
-    getProxyObject() {
-        return this._proxyObj;
-    }
-}
-class EditorWorkerHost {
-    constructor(workerClient) {
-        this._workerClient = workerClient;
+    setChannel(channel, handler) {
+        throw ( new Error(`Not supported`));
     }
-    fhr(method, args) {
-        return this._workerClient.fhr(method, args);
+    getChannel(channel) {
+        throw ( new Error(`Not supported`));
     }
 }
-class EditorWorkerClient extends Disposable {
-    constructor(modelService, keepIdleModels, label, languageConfigurationService) {
+let EditorWorkerClient = class EditorWorkerClient extends Disposable {
+    constructor(_workerDescriptor, keepIdleModels, modelService) {
         super();
-        this.languageConfigurationService = languageConfigurationService;
+        this._workerDescriptor = _workerDescriptor;
         this._disposed = false;
         this._modelService = modelService;
         this._keepIdleModels = keepIdleModels;
-        this._workerFactory = ( new DefaultWorkerFactory(label));
         this._worker = null;
         this._modelManager = null;
     }
@@ -363,114 +309,62 @@ class EditorWorkerClient extends Disposable {
     _getOrCreateWorker() {
         if (!this._worker) {
             try {
-                this._worker = this._register(( new SimpleWorkerClient(
-                    this._workerFactory,
-                    'vs/editor/common/services/editorSimpleWorker',
-                    ( new EditorWorkerHost(this))
-                )));
+                this._worker = this._register(createWebWorker(this._workerDescriptor));
+                EditorWorkerHost.setChannel(this._worker, this._createEditorWorkerHost());
             }
             catch (err) {
                 logOnceWebWorkerWarning(err);
-                this._worker = ( new SynchronousWorkerClient(( new EditorSimpleWorker(( new EditorWorkerHost(this)), null))));
+                this._worker = this._createFallbackLocalWorker();
             }
         }
         return this._worker;
     }
-    _getProxy() {
-        return this._getOrCreateWorker().getProxyObject().then(undefined, (err) => {
+    async _getProxy() {
+        try {
+            const proxy = this._getOrCreateWorker().proxy;
+            await proxy.$ping();
+            return proxy;
+        }
+        catch (err) {
             logOnceWebWorkerWarning(err);
-            this._worker = ( new SynchronousWorkerClient(( new EditorSimpleWorker(( new EditorWorkerHost(this)), null))));
-            return this._getOrCreateWorker().getProxyObject();
-        });
+            this._worker = this._createFallbackLocalWorker();
+            return this._worker.proxy;
+        }
+    }
+    _createFallbackLocalWorker() {
+        return ( new SynchronousWorkerClient(( new EditorSimpleWorker(this._createEditorWorkerHost(), null))));
+    }
+    _createEditorWorkerHost() {
+        return {
+            $fhr: (method, args) => this.fhr(method, args)
+        };
     }
     _getOrCreateModelManager(proxy) {
         if (!this._modelManager) {
-            this._modelManager = this._register(( new EditorModelManager(proxy, this._modelService, this._keepIdleModels)));
+            this._modelManager = this._register(( new WorkerTextModelSyncClient(proxy, this._modelService, this._keepIdleModels)));
         }
         return this._modelManager;
     }
-    async _withSyncedResources(resources, forceLargeModels = false) {
+    async workerWithSyncedResources(resources, forceLargeModels = false) {
         if (this._disposed) {
             return Promise.reject(canceled());
         }
-        return this._getProxy().then((proxy) => {
-            this._getOrCreateModelManager(proxy).ensureSyncedResources(resources, forceLargeModels);
-            return proxy;
-        });
-    }
-    computedUnicodeHighlights(uri, options, range) {
-        return this._withSyncedResources([uri]).then(proxy => {
-            return proxy.computeUnicodeHighlights(( uri.toString()), options, range);
-        });
-    }
-    computeDiff(original, modified, options, algorithm) {
-        return this._withSyncedResources([original, modified],  true).then(proxy => {
-            return proxy.computeDiff(( original.toString()), ( modified.toString()), options, algorithm);
-        });
-    }
-    computeDirtyDiff(original, modified, ignoreTrimWhitespace) {
-        return this._withSyncedResources([original, modified]).then(proxy => {
-            return proxy.computeDirtyDiff(( original.toString()), ( modified.toString()), ignoreTrimWhitespace);
-        });
-    }
-    computeMoreMinimalEdits(resource, edits, pretty) {
-        return this._withSyncedResources([resource]).then(proxy => {
-            return proxy.computeMoreMinimalEdits(( resource.toString()), edits, pretty);
-        });
-    }
-    computeHumanReadableDiff(resource, edits, options) {
-        return this._withSyncedResources([resource]).then(proxy => {
-            return proxy.computeHumanReadableDiff(( resource.toString()), edits, options);
-        });
-    }
-    computeLinks(resource) {
-        return this._withSyncedResources([resource]).then(proxy => {
-            return proxy.computeLinks(( resource.toString()));
-        });
-    }
-    computeDefaultDocumentColors(resource) {
-        return this._withSyncedResources([resource]).then(proxy => {
-            return proxy.computeDefaultDocumentColors(( resource.toString()));
-        });
+        const proxy = await this._getProxy();
+        this._getOrCreateModelManager(proxy).ensureSyncedResources(resources, forceLargeModels);
+        return proxy;
     }
     async textualSuggest(resources, leadingWord, wordDefRegExp) {
-        const proxy = await this._withSyncedResources(resources);
+        const proxy = await this.workerWithSyncedResources(resources);
         const wordDef = wordDefRegExp.source;
         const wordDefFlags = wordDefRegExp.flags;
-        return proxy.textualSuggest(( resources.map(r => ( r.toString()))), leadingWord, wordDef, wordDefFlags);
-    }
-    computeWordRanges(resource, range) {
-        return this._withSyncedResources([resource]).then(proxy => {
-            const model = this._modelService.getModel(resource);
-            if (!model) {
-                return Promise.resolve(null);
-            }
-            const wordDefRegExp = this.languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).getWordDefinition();
-            const wordDef = wordDefRegExp.source;
-            const wordDefFlags = wordDefRegExp.flags;
-            return proxy.computeWordRanges(( resource.toString()), range, wordDef, wordDefFlags);
-        });
-    }
-    navigateValueSet(resource, range, up) {
-        return this._withSyncedResources([resource]).then(proxy => {
-            const model = this._modelService.getModel(resource);
-            if (!model) {
-                return null;
-            }
-            const wordDefRegExp = this.languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).getWordDefinition();
-            const wordDef = wordDefRegExp.source;
-            const wordDefFlags = wordDefRegExp.flags;
-            return proxy.navigateValueSet(( resource.toString()), range, up, wordDef, wordDefFlags);
-        });
-    }
-    findSectionHeaders(uri, options) {
-        return this._withSyncedResources([uri]).then(proxy => {
-            return proxy.findSectionHeaders(( uri.toString()), options);
-        });
+        return proxy.$textualSuggest(( resources.map(r => ( r.toString()))), leadingWord, wordDef, wordDefFlags);
     }
     dispose() {
         super.dispose();
         this._disposed = true;
     }
-}
-export { EditorWorkerClient, EditorWorkerHost, EditorWorkerService };
+};
+EditorWorkerClient = ( __decorate([
+    ( __param(2, IModelService))
+], EditorWorkerClient));
+export { EditorWorkerClient, EditorWorkerService };

package/vscode/src/vs/editor/browser/services/hoverService/hoverWidget.js

@@ -151,10 +151,10 @@ let HoverWidget = class HoverWidget extends Widget {
                 hideOnHover = options.persistence.hideOnHover;
             }
         }
-        if (hideOnHover && options.appearance?.showHoverHint) {
+        if (options.appearance?.showHoverHint) {
             const statusBarElement = $('div.hover-row.status-bar');
             const infoElement = $('div.info');
-            infoElement.textContent = ( localize(5237, 'Hold {0} key to mouse over', isMacintosh ? 'Option' : 'Alt'));
+            infoElement.textContent = ( localize(4350, 'Hold {0} key to mouse over', isMacintosh ? 'Option' : 'Alt'));
             statusBarElement.appendChild(infoElement);
             this._hover.containerDomNode.appendChild(statusBarElement);
         }

package/vscode/src/vs/editor/browser/services/hoverService/updatableHoverWidget.js

@@ -27,7 +27,7 @@ class ManagedHoverWidget {
         }
         else {
             if (!this._hoverWidget) {
-                this.show(( localize(5238, "Loading...")), focus, options);
+                this.show(( localize(4351, "Loading...")), focus, options);
             }
             this._cancellationTokenSource = ( (new CancellationTokenSource()));
             const token = this._cancellationTokenSource.token;
@@ -47,14 +47,17 @@ class ManagedHoverWidget {
             const hoverOptions = {
                 content,
                 target: this.target,
+                actions: options?.actions,
+                linkHandler: options?.linkHandler,
+                trapFocus: options?.trapFocus,
                 appearance: {
                     showPointer: this.hoverDelegate.placement === 'element',
                     skipFadeInAnimation: !this.fadeInAnimation || !!oldHoverWidget,
+                    showHoverHint: options?.appearance?.showHoverHint,
                 },
                 position: {
                     hoverPosition: HoverPosition.BELOW,
                 },
-                ...options
             };
             this._hoverWidget = this.hoverDelegate.showHover(hoverOptions, focus);
         }