@codingame/monaco-vscode-api 8.0.4 → 9.0.2

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(4885, 'Hold {0} key to mouse over', isMacintosh ? 'Option' : 'Alt'));
+            infoElement.textContent = ( localize(5215, '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(4884, "Loading...")), focus, options);
+                this.show(( localize(5216, "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);
         }

package/vscode/src/vs/editor/browser/view/viewLayer.js

@@ -4,8 +4,8 @@ import { BugIndicatingError } from '../../../base/common/errors.js';
 import { EditorOption } from '../../common/config/editorOptions.js';
 import { StringBuilder } from '../../common/core/stringBuilder.js';
 class RenderedLinesCollection {
-    constructor(createLine) {
-        this._createLine = createLine;
+    constructor(_lineFactory) {
+        this._lineFactory = _lineFactory;
         this._set(1, []);
     }
     flush() {
@@ -114,7 +114,7 @@ class RenderedLinesCollection {
         }
         const newLines = [];
         for (let i = 0; i < insertCnt; i++) {
-            newLines[i] = this._createLine();
+            newLines[i] = this._lineFactory.createLine();
         }
         const insertIndex = insertFromLineNumber - this._rendLineNumberStart;
         const beforeLines = this._lines.slice(0, insertIndex);
@@ -147,10 +147,10 @@ class RenderedLinesCollection {
     }
 }
 class VisibleLinesCollection {
-    constructor(host) {
-        this._host = host;
+    constructor(_lineFactory) {
+        this._lineFactory = _lineFactory;
         this.domNode = this._createDomNode();
-        this._linesCollection = ( new RenderedLinesCollection(() => this._host.createVisibleLine()));
+        this._linesCollection = ( new RenderedLinesCollection(this._lineFactory));
     }
     _createDomNode() {
         const domNode = createFastDomNode(document.createElement('div'));
@@ -213,7 +213,7 @@ class VisibleLinesCollection {
     }
     renderLines(viewportData) {
         const inp = this._linesCollection._get();
-        const renderer = ( new ViewLayerRenderer(this.domNode.domNode, this._host, viewportData));
+        const renderer = ( new ViewLayerRenderer(this.domNode.domNode, this._lineFactory, viewportData));
         const ctx = {
             rendLineNumberStart: inp.rendLineNumberStart,
             lines: inp.lines,
@@ -225,10 +225,10 @@ class VisibleLinesCollection {
 }
 class ViewLayerRenderer {
     static { this._ttPolicy = createTrustedTypesPolicy('editorViewLayer', { createHTML: value => value }); }
-    constructor(domNode, host, viewportData) {
-        this.domNode = domNode;
-        this.host = host;
-        this.viewportData = viewportData;
+    constructor(_domNode, _lineFactory, _viewportData) {
+        this._domNode = _domNode;
+        this._lineFactory = _lineFactory;
+        this._viewportData = _viewportData;
     }
     render(inContext, startLineNumber, stopLineNumber, deltaTop) {
         const ctx = {
@@ -241,7 +241,7 @@ class ViewLayerRenderer {
             ctx.linesLength = stopLineNumber - startLineNumber + 1;
             ctx.lines = [];
             for (let x = startLineNumber; x <= stopLineNumber; x++) {
-                ctx.lines[x - startLineNumber] = this.host.createVisibleLine();
+                ctx.lines[x - startLineNumber] = this._lineFactory.createLine();
             }
             this._finishRendering(ctx, true, deltaTop);
             return ctx;
@@ -288,14 +288,14 @@ class ViewLayerRenderer {
         const lines = ctx.lines;
         for (let i = startIndex; i <= endIndex; i++) {
             const lineNumber = rendLineNumberStart + i;
-            lines[i].layoutLine(lineNumber, deltaTop[lineNumber - deltaLN], this.viewportData.lineHeight);
+            lines[i].layoutLine(lineNumber, deltaTop[lineNumber - deltaLN], this._viewportData.lineHeight);
         }
     }
     _insertLinesBefore(ctx, fromLineNumber, toLineNumber, deltaTop, deltaLN) {
         const newLines = [];
         let newLinesLen = 0;
         for (let lineNumber = fromLineNumber; lineNumber <= toLineNumber; lineNumber++) {
-            newLines[newLinesLen++] = this.host.createVisibleLine();
+            newLines[newLinesLen++] = this._lineFactory.createLine();
         }
         ctx.lines = newLines.concat(ctx.lines);
     }
@@ -310,7 +310,7 @@ class ViewLayerRenderer {
         const newLines = [];
         let newLinesLen = 0;
         for (let lineNumber = fromLineNumber; lineNumber <= toLineNumber; lineNumber++) {
-            newLines[newLinesLen++] = this.host.createVisibleLine();
+            newLines[newLinesLen++] = this._lineFactory.createLine();
         }
         ctx.lines = ctx.lines.concat(newLines);
     }
@@ -326,14 +326,14 @@ class ViewLayerRenderer {
         if (ViewLayerRenderer._ttPolicy) {
             newLinesHTML = ViewLayerRenderer._ttPolicy.createHTML(newLinesHTML);
         }
-        const lastChild = this.domNode.lastChild;
+        const lastChild = this._domNode.lastChild;
         if (domNodeIsEmpty || !lastChild) {
-            this.domNode.innerHTML = newLinesHTML;
+            this._domNode.innerHTML = newLinesHTML;
         }
         else {
             lastChild.insertAdjacentHTML('afterend', newLinesHTML);
         }
-        let currChild = this.domNode.lastChild;
+        let currChild = this._domNode.lastChild;
         for (let i = ctx.linesLength - 1; i >= 0; i--) {
             const line = ctx.lines[i];
             if (wasNew[i]) {
@@ -375,7 +375,7 @@ class ViewLayerRenderer {
                 if (lineDomNode) {
                     continue;
                 }
-                const renderResult = line.renderLine(i + rendLineNumberStart, deltaTop[i], this.viewportData.lineHeight, this.viewportData, sb);
+                const renderResult = line.renderLine(i + rendLineNumberStart, deltaTop[i], this._viewportData.lineHeight, this._viewportData, sb);
                 if (!renderResult) {
                     continue;
                 }
@@ -396,7 +396,7 @@ class ViewLayerRenderer {
                 if (wasNew[i]) {
                     continue;
                 }
-                const renderResult = line.renderLine(i + rendLineNumberStart, deltaTop[i], this.viewportData.lineHeight, this.viewportData, sb);
+                const renderResult = line.renderLine(i + rendLineNumberStart, deltaTop[i], this._viewportData.lineHeight, this._viewportData, sb);
                 if (!renderResult) {
                     continue;
                 }