monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/editorScrollbar.js

@@ -0,0 +1,151 @@
+import { addDisposableListener } from '../../../../base/browser/dom.js';
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { SmoothScrollableElement } from '../../../../base/browser/ui/scrollbar/scrollableElement.js';
+import { ViewPart, PartFingerprints } from '../../view/viewPart.js';
+import { getThemeTypeSelector } from '../../../../platform/theme/common/themeService.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * The editor scrollbar built on VS Code's scrollable element that sits beside
+ * the minimap.
+ */
+class EditorScrollbar extends ViewPart {
+    constructor(context, linesContent, viewDomNode, overflowGuardDomNode) {
+        super(context);
+        const options = this._context.configuration.options;
+        const scrollbar = options.get(117 /* EditorOption.scrollbar */);
+        const mouseWheelScrollSensitivity = options.get(83 /* EditorOption.mouseWheelScrollSensitivity */);
+        const fastScrollSensitivity = options.get(49 /* EditorOption.fastScrollSensitivity */);
+        const scrollPredominantAxis = options.get(120 /* EditorOption.scrollPredominantAxis */);
+        const inertialScroll = options.get(158 /* EditorOption.inertialScroll */);
+        const scrollbarOptions = {
+            listenOnDomNode: viewDomNode.domNode,
+            className: 'editor-scrollable' + ' ' + getThemeTypeSelector(context.theme.type),
+            useShadows: false,
+            lazyRender: true,
+            vertical: scrollbar.vertical,
+            horizontal: scrollbar.horizontal,
+            verticalHasArrows: scrollbar.verticalHasArrows,
+            horizontalHasArrows: scrollbar.horizontalHasArrows,
+            verticalScrollbarSize: scrollbar.verticalScrollbarSize,
+            verticalSliderSize: scrollbar.verticalSliderSize,
+            horizontalScrollbarSize: scrollbar.horizontalScrollbarSize,
+            horizontalSliderSize: scrollbar.horizontalSliderSize,
+            handleMouseWheel: scrollbar.handleMouseWheel,
+            alwaysConsumeMouseWheel: scrollbar.alwaysConsumeMouseWheel,
+            arrowSize: scrollbar.arrowSize,
+            mouseWheelScrollSensitivity: mouseWheelScrollSensitivity,
+            fastScrollSensitivity: fastScrollSensitivity,
+            scrollPredominantAxis: scrollPredominantAxis,
+            scrollByPage: scrollbar.scrollByPage,
+            inertialScroll: inertialScroll,
+        };
+        this.scrollbar = this._register(new SmoothScrollableElement(linesContent.domNode, scrollbarOptions, this._context.viewLayout.getScrollable()));
+        PartFingerprints.write(this.scrollbar.getDomNode(), 6 /* PartFingerprint.ScrollableElement */);
+        this.scrollbarDomNode = createFastDomNode(this.scrollbar.getDomNode());
+        this.scrollbarDomNode.setPosition('absolute');
+        this._setLayout();
+        // When having a zone widget that calls .focus() on one of its dom elements,
+        // the browser will try desperately to reveal that dom node, unexpectedly
+        // changing the .scrollTop of this.linesContent
+        const onBrowserDesperateReveal = (domNode, lookAtScrollTop, lookAtScrollLeft) => {
+            const newScrollPosition = {};
+            {
+                const deltaTop = domNode.scrollTop;
+                if (deltaTop) {
+                    newScrollPosition.scrollTop = this._context.viewLayout.getCurrentScrollTop() + deltaTop;
+                    domNode.scrollTop = 0;
+                }
+            }
+            if (lookAtScrollLeft) {
+                const deltaLeft = domNode.scrollLeft;
+                if (deltaLeft) {
+                    newScrollPosition.scrollLeft = this._context.viewLayout.getCurrentScrollLeft() + deltaLeft;
+                    domNode.scrollLeft = 0;
+                }
+            }
+            this._context.viewModel.viewLayout.setScrollPosition(newScrollPosition, 1 /* ScrollType.Immediate */);
+        };
+        // I've seen this happen both on the view dom node & on the lines content dom node.
+        this._register(addDisposableListener(viewDomNode.domNode, 'scroll', (e) => onBrowserDesperateReveal(viewDomNode.domNode, true, true)));
+        this._register(addDisposableListener(linesContent.domNode, 'scroll', (e) => onBrowserDesperateReveal(linesContent.domNode, true, false)));
+        this._register(addDisposableListener(overflowGuardDomNode.domNode, 'scroll', (e) => onBrowserDesperateReveal(overflowGuardDomNode.domNode, true, false)));
+        this._register(addDisposableListener(this.scrollbarDomNode.domNode, 'scroll', (e) => onBrowserDesperateReveal(this.scrollbarDomNode.domNode, true, false)));
+    }
+    dispose() {
+        super.dispose();
+    }
+    _setLayout() {
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+        this.scrollbarDomNode.setLeft(layoutInfo.contentLeft);
+        const minimap = options.get(81 /* EditorOption.minimap */);
+        const side = minimap.side;
+        if (side === 'right') {
+            this.scrollbarDomNode.setWidth(layoutInfo.contentWidth + layoutInfo.minimap.minimapWidth);
+        }
+        else {
+            this.scrollbarDomNode.setWidth(layoutInfo.contentWidth);
+        }
+        this.scrollbarDomNode.setHeight(layoutInfo.height);
+    }
+    getOverviewRulerLayoutInfo() {
+        return this.scrollbar.getOverviewRulerLayoutInfo();
+    }
+    getDomNode() {
+        return this.scrollbarDomNode;
+    }
+    delegateVerticalScrollbarPointerDown(browserEvent) {
+        this.scrollbar.delegateVerticalScrollbarPointerDown(browserEvent);
+    }
+    delegateScrollFromMouseWheelEvent(browserEvent) {
+        this.scrollbar.delegateScrollFromMouseWheelEvent(browserEvent);
+    }
+    // --- begin event handlers
+    onConfigurationChanged(e) {
+        if (e.hasChanged(117 /* EditorOption.scrollbar */)
+            || e.hasChanged(83 /* EditorOption.mouseWheelScrollSensitivity */)
+            || e.hasChanged(49 /* EditorOption.fastScrollSensitivity */)) {
+            const options = this._context.configuration.options;
+            const scrollbar = options.get(117 /* EditorOption.scrollbar */);
+            const mouseWheelScrollSensitivity = options.get(83 /* EditorOption.mouseWheelScrollSensitivity */);
+            const fastScrollSensitivity = options.get(49 /* EditorOption.fastScrollSensitivity */);
+            const scrollPredominantAxis = options.get(120 /* EditorOption.scrollPredominantAxis */);
+            const newOpts = {
+                vertical: scrollbar.vertical,
+                horizontal: scrollbar.horizontal,
+                verticalScrollbarSize: scrollbar.verticalScrollbarSize,
+                horizontalScrollbarSize: scrollbar.horizontalScrollbarSize,
+                scrollByPage: scrollbar.scrollByPage,
+                handleMouseWheel: scrollbar.handleMouseWheel,
+                mouseWheelScrollSensitivity: mouseWheelScrollSensitivity,
+                fastScrollSensitivity: fastScrollSensitivity,
+                scrollPredominantAxis: scrollPredominantAxis
+            };
+            this.scrollbar.updateOptions(newOpts);
+        }
+        if (e.hasChanged(165 /* EditorOption.layoutInfo */)) {
+            this._setLayout();
+        }
+        return true;
+    }
+    onScrollChanged(e) {
+        return true;
+    }
+    onThemeChanged(e) {
+        this.scrollbar.updateClassName('editor-scrollable' + ' ' + getThemeTypeSelector(this._context.theme.type));
+        return true;
+    }
+    // --- end event handlers
+    prepareRender(ctx) {
+        // Nothing to do
+    }
+    render(ctx) {
+        this.scrollbar.renderNow();
+    }
+}
+
+export { EditorScrollbar };

package/dist/workers/editorState.js

@@ -0,0 +1,115 @@
+import { format } from '../../../../base/common/strings.js';
+import { Range } from '../../../common/core/range.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { EditorKeybindingCancellationTokenSource } from './keybindingCancellation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class EditorState {
+    constructor(editor, flags) {
+        this.flags = flags;
+        if ((this.flags & 1 /* CodeEditorStateFlag.Value */) !== 0) {
+            const model = editor.getModel();
+            this.modelVersionId = model ? format('{0}#{1}', model.uri.toString(), model.getVersionId()) : null;
+        }
+        else {
+            this.modelVersionId = null;
+        }
+        if ((this.flags & 4 /* CodeEditorStateFlag.Position */) !== 0) {
+            this.position = editor.getPosition();
+        }
+        else {
+            this.position = null;
+        }
+        if ((this.flags & 2 /* CodeEditorStateFlag.Selection */) !== 0) {
+            this.selection = editor.getSelection();
+        }
+        else {
+            this.selection = null;
+        }
+        if ((this.flags & 8 /* CodeEditorStateFlag.Scroll */) !== 0) {
+            this.scrollLeft = editor.getScrollLeft();
+            this.scrollTop = editor.getScrollTop();
+        }
+        else {
+            this.scrollLeft = -1;
+            this.scrollTop = -1;
+        }
+    }
+    _equals(other) {
+        if (!(other instanceof EditorState)) {
+            return false;
+        }
+        const state = other;
+        if (this.modelVersionId !== state.modelVersionId) {
+            return false;
+        }
+        if (this.scrollLeft !== state.scrollLeft || this.scrollTop !== state.scrollTop) {
+            return false;
+        }
+        if (!this.position && state.position || this.position && !state.position || this.position && state.position && !this.position.equals(state.position)) {
+            return false;
+        }
+        if (!this.selection && state.selection || this.selection && !state.selection || this.selection && state.selection && !this.selection.equalsRange(state.selection)) {
+            return false;
+        }
+        return true;
+    }
+    validate(editor) {
+        return this._equals(new EditorState(editor, this.flags));
+    }
+}
+/**
+ * A cancellation token source that cancels when the editor changes as expressed
+ * by the provided flags
+ * @param range If provided, changes in position and selection within this range will not trigger cancellation
+ */
+class EditorStateCancellationTokenSource extends EditorKeybindingCancellationTokenSource {
+    constructor(editor, flags, range, parent) {
+        super(editor, parent);
+        this._listener = new DisposableStore();
+        if (flags & 4 /* CodeEditorStateFlag.Position */) {
+            this._listener.add(editor.onDidChangeCursorPosition(e => {
+                if (!range || !Range.containsPosition(range, e.position)) {
+                    this.cancel();
+                }
+            }));
+        }
+        if (flags & 2 /* CodeEditorStateFlag.Selection */) {
+            this._listener.add(editor.onDidChangeCursorSelection(e => {
+                if (!range || !Range.containsRange(range, e.selection)) {
+                    this.cancel();
+                }
+            }));
+        }
+        if (flags & 8 /* CodeEditorStateFlag.Scroll */) {
+            this._listener.add(editor.onDidScrollChange(_ => this.cancel()));
+        }
+        if (flags & 1 /* CodeEditorStateFlag.Value */) {
+            this._listener.add(editor.onDidChangeModel(_ => this.cancel()));
+            this._listener.add(editor.onDidChangeModelContent(_ => this.cancel()));
+        }
+    }
+    dispose() {
+        this._listener.dispose();
+        super.dispose();
+    }
+}
+/**
+ * A cancellation token source that cancels when the provided model changes
+ */
+class TextModelCancellationTokenSource extends CancellationTokenSource {
+    constructor(model, parent) {
+        super(parent);
+        this._listener = model.onDidChangeContent(() => this.cancel());
+    }
+    dispose() {
+        this._listener.dispose();
+        super.dispose();
+    }
+}
+
+export { EditorState, EditorStateCancellationTokenSource, TextModelCancellationTokenSource };

package/dist/workers/editorTheme.js

@@ -0,0 +1,23 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class EditorTheme {
+    get type() {
+        return this._theme.type;
+    }
+    get value() {
+        return this._theme;
+    }
+    constructor(theme) {
+        this._theme = theme;
+    }
+    update(theme) {
+        this._theme = theme;
+    }
+    getColor(color) {
+        return this._theme.getColor(color);
+    }
+}
+
+export { EditorTheme };

package/dist/workers/editorWebWorker.js

@@ -0,0 +1,299 @@
+import { stringDiff } from '../../../base/common/diff/diff.js';
+import { Range } from '../core/range.js';
+import { computeLinks } from '../languages/linkComputer.js';
+import { BasicInplaceReplace } from '../languages/supports/inplaceReplaceSupport.js';
+import { createMonacoBaseAPI } from './editorBaseApi.js';
+import { StopWatch } from '../../../base/common/stopwatch.js';
+import { UnicodeTextModelHighlighter } from './unicodeTextModelHighlighter.js';
+import { linesDiffComputers } from '../diff/linesDiffComputers.js';
+import { computeDefaultDocumentColors } from '../languages/defaultDocumentColorsComputer.js';
+import { findSectionHeaders } from './findSectionHeaders.js';
+import { WorkerTextModelSyncServer } from './textModelSync/textModelSync.impl.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * @internal
+ */
+class EditorWorker {
+    constructor(_foreignModule = null) {
+        this._foreignModule = _foreignModule;
+        this._requestHandlerBrand = undefined;
+        this._workerTextModelSyncServer = new WorkerTextModelSyncServer();
+    }
+    dispose() {
+    }
+    async $ping() {
+        return 'pong';
+    }
+    _getModel(uri) {
+        return this._workerTextModelSyncServer.getModel(uri);
+    }
+    getModels() {
+        return this._workerTextModelSyncServer.getModels();
+    }
+    $acceptNewModel(data) {
+        this._workerTextModelSyncServer.$acceptNewModel(data);
+    }
+    $acceptModelChanged(uri, e) {
+        this._workerTextModelSyncServer.$acceptModelChanged(uri, e);
+    }
+    $acceptRemovedModel(uri) {
+        this._workerTextModelSyncServer.$acceptRemovedModel(uri);
+    }
+    async $computeUnicodeHighlights(url, options, range) {
+        const model = this._getModel(url);
+        if (!model) {
+            return { ranges: [], hasMore: false, ambiguousCharacterCount: 0, invisibleCharacterCount: 0, nonBasicAsciiCharacterCount: 0 };
+        }
+        return UnicodeTextModelHighlighter.computeUnicodeHighlights(model, options, range);
+    }
+    async $findSectionHeaders(url, options) {
+        const model = this._getModel(url);
+        if (!model) {
+            return [];
+        }
+        return findSectionHeaders(model, options);
+    }
+    // ---- BEGIN diff --------------------------------------------------------------------------
+    async $computeDiff(originalUrl, modifiedUrl, options, algorithm) {
+        const original = this._getModel(originalUrl);
+        const modified = this._getModel(modifiedUrl);
+        if (!original || !modified) {
+            return null;
+        }
+        const result = EditorWorker.computeDiff(original, modified, options, algorithm);
+        return result;
+    }
+    static computeDiff(originalTextModel, modifiedTextModel, options, algorithm) {
+        const diffAlgorithm = algorithm === 'advanced' ? linesDiffComputers.getDefault() : linesDiffComputers.getLegacy();
+        const originalLines = originalTextModel.getLinesContent();
+        const modifiedLines = modifiedTextModel.getLinesContent();
+        const result = diffAlgorithm.computeDiff(originalLines, modifiedLines, options);
+        const identical = (result.changes.length > 0 ? false : this._modelsAreIdentical(originalTextModel, modifiedTextModel));
+        function getLineChanges(changes) {
+            return changes.map(m => ([m.original.startLineNumber, m.original.endLineNumberExclusive, m.modified.startLineNumber, m.modified.endLineNumberExclusive, m.innerChanges?.map(m => [
+                    m.originalRange.startLineNumber,
+                    m.originalRange.startColumn,
+                    m.originalRange.endLineNumber,
+                    m.originalRange.endColumn,
+                    m.modifiedRange.startLineNumber,
+                    m.modifiedRange.startColumn,
+                    m.modifiedRange.endLineNumber,
+                    m.modifiedRange.endColumn,
+                ])]));
+        }
+        return {
+            identical,
+            quitEarly: result.hitTimeout,
+            changes: getLineChanges(result.changes),
+            moves: result.moves.map(m => ([
+                m.lineRangeMapping.original.startLineNumber,
+                m.lineRangeMapping.original.endLineNumberExclusive,
+                m.lineRangeMapping.modified.startLineNumber,
+                m.lineRangeMapping.modified.endLineNumberExclusive,
+                getLineChanges(m.changes)
+            ])),
+        };
+    }
+    static _modelsAreIdentical(original, modified) {
+        const originalLineCount = original.getLineCount();
+        const modifiedLineCount = modified.getLineCount();
+        if (originalLineCount !== modifiedLineCount) {
+            return false;
+        }
+        for (let line = 1; line <= originalLineCount; line++) {
+            const originalLine = original.getLineContent(line);
+            const modifiedLine = modified.getLineContent(line);
+            if (originalLine !== modifiedLine) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // ---- END diff --------------------------------------------------------------------------
+    // ---- BEGIN minimal edits ---------------------------------------------------------------
+    static { this._diffLimit = 100000; }
+    async $computeMoreMinimalEdits(modelUrl, edits, pretty) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return edits;
+        }
+        const result = [];
+        let lastEol = undefined;
+        edits = edits.slice(0).sort((a, b) => {
+            if (a.range && b.range) {
+                return Range.compareRangesUsingStarts(a.range, b.range);
+            }
+            // eol only changes should go to the end
+            const aRng = a.range ? 0 : 1;
+            const bRng = b.range ? 0 : 1;
+            return aRng - bRng;
+        });
+        // merge adjacent edits
+        let writeIndex = 0;
+        for (let readIndex = 1; readIndex < edits.length; readIndex++) {
+            if (Range.getEndPosition(edits[writeIndex].range).equals(Range.getStartPosition(edits[readIndex].range))) {
+                edits[writeIndex].range = Range.fromPositions(Range.getStartPosition(edits[writeIndex].range), Range.getEndPosition(edits[readIndex].range));
+                edits[writeIndex].text += edits[readIndex].text;
+            }
+            else {
+                writeIndex++;
+                edits[writeIndex] = edits[readIndex];
+            }
+        }
+        edits.length = writeIndex + 1;
+        for (let { range, text, eol } of edits) {
+            if (typeof eol === 'number') {
+                lastEol = eol;
+            }
+            if (Range.isEmpty(range) && !text) {
+                // empty change
+                continue;
+            }
+            const original = model.getValueInRange(range);
+            text = text.replace(/\r\n|\n|\r/g, model.eol);
+            if (original === text) {
+                // noop
+                continue;
+            }
+            // make sure diff won't take too long
+            if (Math.max(text.length, original.length) > EditorWorker._diffLimit) {
+                result.push({ range, text });
+                continue;
+            }
+            // compute diff between original and edit.text
+            const changes = stringDiff(original, text, pretty);
+            const editOffset = model.offsetAt(Range.lift(range).getStartPosition());
+            for (const change of changes) {
+                const start = model.positionAt(editOffset + change.originalStart);
+                const end = model.positionAt(editOffset + change.originalStart + change.originalLength);
+                const newEdit = {
+                    text: text.substr(change.modifiedStart, change.modifiedLength),
+                    range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }
+                };
+                if (model.getValueInRange(newEdit.range) !== newEdit.text) {
+                    result.push(newEdit);
+                }
+            }
+        }
+        if (typeof lastEol === 'number') {
+            result.push({ eol: lastEol, text: '', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } });
+        }
+        return result;
+    }
+    // ---- END minimal edits ---------------------------------------------------------------
+    async $computeLinks(modelUrl) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return null;
+        }
+        return computeLinks(model);
+    }
+    // --- BEGIN default document colors -----------------------------------------------------------
+    async $computeDefaultDocumentColors(modelUrl) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return null;
+        }
+        return computeDefaultDocumentColors(model);
+    }
+    // ---- BEGIN suggest --------------------------------------------------------------------------
+    static { this._suggestionsLimit = 10000; }
+    async $textualSuggest(modelUrls, leadingWord, wordDef, wordDefFlags) {
+        const sw = new StopWatch();
+        const wordDefRegExp = new RegExp(wordDef, wordDefFlags);
+        const seen = new Set();
+        outer: for (const url of modelUrls) {
+            const model = this._getModel(url);
+            if (!model) {
+                continue;
+            }
+            for (const word of model.words(wordDefRegExp)) {
+                if (word === leadingWord || !isNaN(Number(word))) {
+                    continue;
+                }
+                seen.add(word);
+                if (seen.size > EditorWorker._suggestionsLimit) {
+                    break outer;
+                }
+            }
+        }
+        return { words: Array.from(seen), duration: sw.elapsed() };
+    }
+    // ---- END suggest --------------------------------------------------------------------------
+    //#region -- word ranges --
+    async $computeWordRanges(modelUrl, range, wordDef, wordDefFlags) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return Object.create(null);
+        }
+        const wordDefRegExp = new RegExp(wordDef, wordDefFlags);
+        const result = Object.create(null);
+        for (let line = range.startLineNumber; line < range.endLineNumber; line++) {
+            const words = model.getLineWords(line, wordDefRegExp);
+            for (const word of words) {
+                if (!isNaN(Number(word.word))) {
+                    continue;
+                }
+                let array = result[word.word];
+                if (!array) {
+                    array = [];
+                    result[word.word] = array;
+                }
+                array.push({
+                    startLineNumber: line,
+                    startColumn: word.startColumn,
+                    endLineNumber: line,
+                    endColumn: word.endColumn
+                });
+            }
+        }
+        return result;
+    }
+    //#endregion
+    async $navigateValueSet(modelUrl, range, up, wordDef, wordDefFlags) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return null;
+        }
+        const wordDefRegExp = new RegExp(wordDef, wordDefFlags);
+        if (range.startColumn === range.endColumn) {
+            range = {
+                startLineNumber: range.startLineNumber,
+                startColumn: range.startColumn,
+                endLineNumber: range.endLineNumber,
+                endColumn: range.endColumn + 1
+            };
+        }
+        const selectionText = model.getValueInRange(range);
+        const wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);
+        if (!wordRange) {
+            return null;
+        }
+        const word = model.getValueInRange(wordRange);
+        const result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);
+        return result;
+    }
+    // ---- BEGIN foreign module support --------------------------------------------------------------------------
+    // foreign method request
+    $fmr(method, args) {
+        if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {
+            return Promise.reject(new Error('Missing requestHandler or method: ' + method));
+        }
+        try {
+            return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    }
+}
+if (typeof importScripts === 'function') {
+    // Running in a web worker
+    globalThis.monaco = createMonacoBaseAPI();
+}
+
+export { EditorWorker };

package/dist/workers/editorWorker.js

@@ -0,0 +1,9 @@
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const IEditorWorkerService = createDecorator('editorWorkerService');
+
+export { IEditorWorkerService };

package/dist/workers/editorWorkerHost.js

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class EditorWorkerHost {
+    static { this.CHANNEL_NAME = 'editorWorkerHost'; }
+    static getChannel(workerServer) {
+        return workerServer.getChannel(EditorWorkerHost.CHANNEL_NAME);
+    }
+    static setChannel(workerClient, obj) {
+        workerClient.setChannel(EditorWorkerHost.CHANNEL_NAME, obj);
+    }
+}
+
+export { EditorWorkerHost };