monaco-editor11 1.0.7 → 1.0.9

package/dist/workers/editor/common/wordCharacterClassifier.js

@@ -0,0 +1,87 @@
+import { safeIntl } from '../../../base/common/date.js';
+import { LRUCache } from '../../../base/common/map.js';
+import { CharacterClassifier } from './characterClassifier.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class WordCharacterClassifier extends CharacterClassifier {
+    constructor(wordSeparators, intlSegmenterLocales) {
+        super(0 /* WordCharacterClass.Regular */);
+        this._segmenter = null;
+        this._cachedLine = null;
+        this._cachedSegments = [];
+        this.intlSegmenterLocales = intlSegmenterLocales;
+        if (this.intlSegmenterLocales.length > 0) {
+            this._segmenter = safeIntl.Segmenter(this.intlSegmenterLocales, { granularity: 'word' });
+        }
+        else {
+            this._segmenter = null;
+        }
+        for (let i = 0, len = wordSeparators.length; i < len; i++) {
+            this.set(wordSeparators.charCodeAt(i), 2 /* WordCharacterClass.WordSeparator */);
+        }
+        this.set(32 /* CharCode.Space */, 1 /* WordCharacterClass.Whitespace */);
+        this.set(9 /* CharCode.Tab */, 1 /* WordCharacterClass.Whitespace */);
+    }
+    findPrevIntlWordBeforeOrAtOffset(line, offset) {
+        let candidate = null;
+        for (const segment of this._getIntlSegmenterWordsOnLine(line)) {
+            if (segment.index > offset) {
+                break;
+            }
+            candidate = segment;
+        }
+        return candidate;
+    }
+    findNextIntlWordAtOrAfterOffset(lineContent, offset) {
+        for (const segment of this._getIntlSegmenterWordsOnLine(lineContent)) {
+            if (segment.index < offset) {
+                continue;
+            }
+            return segment;
+        }
+        return null;
+    }
+    _getIntlSegmenterWordsOnLine(line) {
+        if (!this._segmenter) {
+            return [];
+        }
+        // Check if the line has changed from the previous call
+        if (this._cachedLine === line) {
+            return this._cachedSegments;
+        }
+        // Update the cache with the new line
+        this._cachedLine = line;
+        this._cachedSegments = this._filterWordSegments(this._segmenter.value.segment(line));
+        return this._cachedSegments;
+    }
+    _filterWordSegments(segments) {
+        const result = [];
+        for (const segment of segments) {
+            if (this._isWordLike(segment)) {
+                result.push(segment);
+            }
+        }
+        return result;
+    }
+    _isWordLike(segment) {
+        if (segment.isWordLike) {
+            return true;
+        }
+        return false;
+    }
+}
+const wordClassifierCache = new LRUCache(10);
+function getMapForWordSeparators(wordSeparators, intlSegmenterLocales) {
+    const key = `${wordSeparators}/${intlSegmenterLocales.join(',')}`;
+    let result = wordClassifierCache.get(key);
+    if (!result) {
+        result = new WordCharacterClassifier(wordSeparators, intlSegmenterLocales);
+        wordClassifierCache.set(key, result);
+    }
+    return result;
+}
+
+export { WordCharacterClassifier, getMapForWordSeparators };

package/dist/workers/editor/common/wordHelper.js

@@ -0,0 +1,127 @@
+import { Iterable } from '../../../base/common/iterator.js';
+import { LinkedList } from '../../../base/common/linkedList.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?';
+/**
+ * Create a word definition regular expression based on default word separators.
+ * Optionally provide allowed separators that should be included in words.
+ *
+ * The default would look like this:
+ * /(-?\d*\.\d\w*)|([^\`\~\!\@\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g
+ */
+function createWordRegExp(allowInWords = '') {
+    let source = '(-?\\d*\\.\\d\\w*)|([^';
+    for (const sep of USUAL_WORD_SEPARATORS) {
+        if (allowInWords.indexOf(sep) >= 0) {
+            continue;
+        }
+        source += '\\' + sep;
+    }
+    source += '\\s]+)';
+    return new RegExp(source, 'g');
+}
+// catches numbers (including floating numbers) in the first group, and alphanum in the second
+const DEFAULT_WORD_REGEXP = createWordRegExp();
+function ensureValidWordDefinition(wordDefinition) {
+    let result = DEFAULT_WORD_REGEXP;
+    if (wordDefinition && (wordDefinition instanceof RegExp)) {
+        if (!wordDefinition.global) {
+            let flags = 'g';
+            if (wordDefinition.ignoreCase) {
+                flags += 'i';
+            }
+            if (wordDefinition.multiline) {
+                flags += 'm';
+            }
+            if (wordDefinition.unicode) {
+                flags += 'u';
+            }
+            result = new RegExp(wordDefinition.source, flags);
+        }
+        else {
+            result = wordDefinition;
+        }
+    }
+    result.lastIndex = 0;
+    return result;
+}
+const _defaultConfig = new LinkedList();
+_defaultConfig.unshift({
+    maxLen: 1000,
+    windowSize: 15,
+    timeBudget: 150
+});
+function getWordAtText(column, wordDefinition, text, textOffset, config) {
+    // Ensure the regex has the 'g' flag, otherwise this will loop forever
+    wordDefinition = ensureValidWordDefinition(wordDefinition);
+    if (!config) {
+        config = Iterable.first(_defaultConfig);
+    }
+    if (text.length > config.maxLen) {
+        // don't throw strings that long at the regexp
+        // but use a sub-string in which a word must occur
+        let start = column - config.maxLen / 2;
+        if (start < 0) {
+            start = 0;
+        }
+        else {
+            textOffset += start;
+        }
+        text = text.substring(start, column + config.maxLen / 2);
+        return getWordAtText(column, wordDefinition, text, textOffset, config);
+    }
+    const t1 = Date.now();
+    const pos = column - 1 - textOffset;
+    let prevRegexIndex = -1;
+    let match = null;
+    for (let i = 1;; i++) {
+        // check time budget
+        if (Date.now() - t1 >= config.timeBudget) {
+            break;
+        }
+        // reset the index at which the regexp should start matching, also know where it
+        // should stop so that subsequent search don't repeat previous searches
+        const regexIndex = pos - config.windowSize * i;
+        wordDefinition.lastIndex = Math.max(0, regexIndex);
+        const thisMatch = _findRegexMatchEnclosingPosition(wordDefinition, text, pos, prevRegexIndex);
+        if (!thisMatch && match) {
+            // stop: we have something
+            break;
+        }
+        match = thisMatch;
+        // stop: searched at start
+        if (regexIndex <= 0) {
+            break;
+        }
+        prevRegexIndex = regexIndex;
+    }
+    if (match) {
+        const result = {
+            word: match[0],
+            startColumn: textOffset + 1 + match.index,
+            endColumn: textOffset + 1 + match.index + match[0].length
+        };
+        wordDefinition.lastIndex = 0;
+        return result;
+    }
+    return null;
+}
+function _findRegexMatchEnclosingPosition(wordDefinition, text, pos, stopPos) {
+    let match;
+    while (match = wordDefinition.exec(text)) {
+        const matchIndex = match.index || 0;
+        if (matchIndex <= pos && wordDefinition.lastIndex >= pos) {
+            return match;
+        }
+        else if (stopPos > 0 && matchIndex > stopPos) {
+            return null;
+        }
+    }
+    return null;
+}
+
+export { DEFAULT_WORD_REGEXP, USUAL_WORD_SEPARATORS, ensureValidWordDefinition, getWordAtText };

package/dist/workers/editor/editor.worker.js

@@ -0,0 +1,11 @@
+import { isWorkerInitialized } from '../common/initialize.js';
+export { initialize } from '../common/initialize.js';
+import { start } from './editor.worker.start.js';
+
+self.onmessage = () => {
+  if (!isWorkerInitialized()) {
+    start(() => {
+      return {};
+    });
+  }
+};

package/dist/workers/language/css.worker.js

@@ -0,0 +1,8 @@
+import { initialize } from '../../common/initialize.js';
+import { CSSWorker } from './cssWorker.js';
+
+self.onmessage = () => {
+  initialize((ctx, createData) => {
+    return new CSSWorker(ctx, createData);
+  });
+};

package/dist/workers/language/cssMode.js

@@ -0,0 +1,198 @@
+import { WorkerManager } from './workerManager.js';
+import { CompletionAdapter, HoverAdapter, DocumentHighlightAdapter, DefinitionAdapter, ReferenceAdapter, DocumentSymbolAdapter, RenameAdapter, DocumentColorAdapter, FoldingRangeAdapter, DiagnosticsAdapter, SelectionRangeAdapter, DocumentFormattingEditProvider, DocumentRangeFormattingEditProvider } from '../common/lspLanguageFeatures.js';
+export { DocumentLinkAdapter, fromPosition, fromRange, toRange, toTextEdit } from '../common/lspLanguageFeatures.js';
+import '../../editor/browser/coreCommands.js';
+import '../../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import '../../editor/browser/widget/diffEditor/diffEditor.contribution.js';
+import '../../editor/contrib/anchorSelect/browser/anchorSelect.js';
+import '../../editor/contrib/bracketMatching/browser/bracketMatching.js';
+import '../../editor/contrib/caretOperations/browser/caretOperations.js';
+import '../../editor/contrib/caretOperations/browser/transpose.js';
+import '../../editor/contrib/clipboard/browser/clipboard.js';
+import '../../editor/contrib/codeAction/browser/codeActionContributions.js';
+import '../../editor/contrib/codelens/browser/codelensController.js';
+import '../../editor/contrib/colorPicker/browser/colorPickerContribution.js';
+import '../../editor/contrib/comment/browser/comment.js';
+import '../../editor/contrib/contextmenu/browser/contextmenu.js';
+import '../../editor/contrib/cursorUndo/browser/cursorUndo.js';
+import '../../editor/contrib/dnd/browser/dnd.js';
+import '../../editor/contrib/dropOrPasteInto/browser/copyPasteContribution.js';
+import '../../editor/contrib/dropOrPasteInto/browser/dropIntoEditorContribution.js';
+import '../../editor/contrib/find/browser/findController.js';
+import '../../editor/contrib/folding/browser/folding.js';
+import '../../editor/contrib/fontZoom/browser/fontZoom.js';
+import '../../editor/contrib/format/browser/formatActions.js';
+import '../../editor/contrib/documentSymbols/browser/documentSymbols.js';
+import '../../editor/contrib/inlineCompletions/browser/inlineCompletions.contribution.js';
+import '../../editor/contrib/inlineProgress/browser/inlineProgress.js';
+import '../../editor/contrib/gotoSymbol/browser/goToCommands.js';
+import '../../editor/contrib/gotoSymbol/browser/link/goToDefinitionAtPosition.js';
+import '../../editor/contrib/gotoError/browser/gotoError.js';
+import '../../editor/contrib/gpu/browser/gpuActions.js';
+import '../../editor/contrib/hover/browser/hoverContribution.js';
+import '../../editor/contrib/indentation/browser/indentation.js';
+import '../../editor/contrib/inlayHints/browser/inlayHintsContribution.js';
+import '../../editor/contrib/inPlaceReplace/browser/inPlaceReplace.js';
+import '../../editor/contrib/insertFinalNewLine/browser/insertFinalNewLine.js';
+import '../../editor/contrib/lineSelection/browser/lineSelection.js';
+import '../../editor/contrib/linesOperations/browser/linesOperations.js';
+import '../../editor/contrib/linkedEditing/browser/linkedEditing.js';
+import '../../editor/contrib/links/browser/links.js';
+import '../../editor/contrib/longLinesHelper/browser/longLinesHelper.js';
+import '../../editor/contrib/middleScroll/browser/middleScroll.contribution.js';
+import '../../editor/contrib/multicursor/browser/multicursor.js';
+import '../../editor/contrib/parameterHints/browser/parameterHints.js';
+import '../../editor/contrib/placeholderText/browser/placeholderText.contribution.js';
+import '../../editor/contrib/rename/browser/rename.js';
+import '../../editor/contrib/sectionHeaders/browser/sectionHeaders.js';
+import '../../editor/contrib/semanticTokens/browser/documentSemanticTokens.js';
+import '../../editor/contrib/semanticTokens/browser/viewportSemanticTokens.js';
+import '../../editor/contrib/smartSelect/browser/smartSelect.js';
+import '../../editor/contrib/snippet/browser/snippetController2.js';
+import '../../editor/contrib/stickyScroll/browser/stickyScrollContribution.js';
+import '../../editor/contrib/suggest/browser/suggestController.js';
+import '../../editor/contrib/suggest/browser/suggestInlineCompletions.js';
+import '../../editor/contrib/tokenization/browser/tokenization.js';
+import '../../editor/contrib/toggleTabFocusMode/browser/toggleTabFocusMode.js';
+import '../../editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.js';
+import '../../editor/contrib/unusualLineTerminators/browser/unusualLineTerminators.js';
+import '../../editor/contrib/wordHighlighter/browser/wordHighlighter.js';
+import '../../editor/contrib/wordOperations/browser/wordOperations.js';
+import '../../editor/contrib/wordPartOperations/browser/wordPartOperations.js';
+import '../../editor/contrib/readOnlyMessage/browser/contribution.js';
+import '../../editor/contrib/diffEditorBreadcrumbs/browser/contribution.js';
+import '../../editor/contrib/floatingMenu/browser/floatingMenu.contribution.js';
+import '../../editor/common/standaloneStrings.js';
+import '../../base/browser/ui/codicons/codicon/codicon.css';
+import '../../base/browser/ui/codicons/codicon/codicon-modifiers.css';
+import '../../editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard.js';
+import '../../editor/standalone/browser/inspectTokens/inspectTokens.js';
+import '../../editor/standalone/browser/quickAccess/standaloneHelpQuickAccess.js';
+import '../../editor/standalone/browser/quickAccess/standaloneGotoLineQuickAccess.js';
+import '../../editor/standalone/browser/quickAccess/standaloneGotoSymbolQuickAccess.js';
+import '../../editor/standalone/browser/quickAccess/standaloneCommandsQuickAccess.js';
+import '../../editor/standalone/browser/referenceSearch/standaloneReferenceSearch.js';
+import '../../editor/standalone/browser/toggleHighContrast/toggleHighContrast.js';
+import { languages } from '../../editor/editor.api2.js';
+
+function setupMode(defaults) {
+  const disposables = [];
+  const providers = [];
+  const client = new WorkerManager(defaults);
+  disposables.push(client);
+  const worker = (...uris) => {
+    return client.getLanguageServiceWorker(...uris);
+  };
+  function registerProviders() {
+    const { languageId, modeConfiguration } = defaults;
+    disposeAll(providers);
+    if (modeConfiguration.completionItems) {
+      providers.push(
+        languages.registerCompletionItemProvider(
+          languageId,
+          new CompletionAdapter(worker, ["/", "-", ":"])
+        )
+      );
+    }
+    if (modeConfiguration.hovers) {
+      providers.push(
+        languages.registerHoverProvider(languageId, new HoverAdapter(worker))
+      );
+    }
+    if (modeConfiguration.documentHighlights) {
+      providers.push(
+        languages.registerDocumentHighlightProvider(
+          languageId,
+          new DocumentHighlightAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.definitions) {
+      providers.push(
+        languages.registerDefinitionProvider(
+          languageId,
+          new DefinitionAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.references) {
+      providers.push(
+        languages.registerReferenceProvider(
+          languageId,
+          new ReferenceAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.documentSymbols) {
+      providers.push(
+        languages.registerDocumentSymbolProvider(
+          languageId,
+          new DocumentSymbolAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.rename) {
+      providers.push(
+        languages.registerRenameProvider(languageId, new RenameAdapter(worker))
+      );
+    }
+    if (modeConfiguration.colors) {
+      providers.push(
+        languages.registerColorProvider(
+          languageId,
+          new DocumentColorAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.foldingRanges) {
+      providers.push(
+        languages.registerFoldingRangeProvider(
+          languageId,
+          new FoldingRangeAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.diagnostics) {
+      providers.push(
+        new DiagnosticsAdapter(languageId, worker, defaults.onDidChange)
+      );
+    }
+    if (modeConfiguration.selectionRanges) {
+      providers.push(
+        languages.registerSelectionRangeProvider(
+          languageId,
+          new SelectionRangeAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.documentFormattingEdits) {
+      providers.push(
+        languages.registerDocumentFormattingEditProvider(
+          languageId,
+          new DocumentFormattingEditProvider(worker)
+        )
+      );
+    }
+    if (modeConfiguration.documentRangeFormattingEdits) {
+      providers.push(
+        languages.registerDocumentRangeFormattingEditProvider(
+          languageId,
+          new DocumentRangeFormattingEditProvider(worker)
+        )
+      );
+    }
+  }
+  registerProviders();
+  disposables.push(asDisposable(providers));
+  return asDisposable(disposables);
+}
+function asDisposable(disposables) {
+  return { dispose: () => disposeAll(disposables) };
+}
+function disposeAll(disposables) {
+  while (disposables.length) {
+    disposables.pop().dispose();
+  }
+}
+
+export { CompletionAdapter, DefinitionAdapter, DiagnosticsAdapter, DocumentColorAdapter, DocumentFormattingEditProvider, DocumentHighlightAdapter, DocumentRangeFormattingEditProvider, DocumentSymbolAdapter, FoldingRangeAdapter, HoverAdapter, ReferenceAdapter, RenameAdapter, SelectionRangeAdapter, WorkerManager, setupMode };

package/dist/workers/language/cssWorker.js

@@ -0,0 +1,183 @@
+import { newCSSDataProvider, getSCSSLanguageService, getLESSLanguageService, getCSSLanguageService } from '../../../external/vscode-css-languageservice/lib/esm/cssLanguageService.js';
+import { TextDocument } from '../../../external/vscode-languageserver-textdocument/lib/esm/main.js';
+
+class CSSWorker {
+  constructor(ctx, createData) {
+    this._ctx = ctx;
+    this._languageSettings = createData.options;
+    this._languageId = createData.languageId;
+    const data = createData.options.data;
+    const useDefaultDataProvider = data?.useDefaultDataProvider;
+    const customDataProviders = [];
+    if (data?.dataProviders) {
+      for (const id in data.dataProviders) {
+        customDataProviders.push(newCSSDataProvider(data.dataProviders[id]));
+      }
+    }
+    const lsOptions = {
+      customDataProviders,
+      useDefaultDataProvider
+    };
+    switch (this._languageId) {
+      case "css":
+        this._languageService = getCSSLanguageService(lsOptions);
+        break;
+      case "less":
+        this._languageService = getLESSLanguageService(lsOptions);
+        break;
+      case "scss":
+        this._languageService = getSCSSLanguageService(lsOptions);
+        break;
+      default:
+        throw new Error("Invalid language id: " + this._languageId);
+    }
+    this._languageService.configure(this._languageSettings);
+  }
+  // --- language service host ---------------
+  async doValidation(uri) {
+    const document = this._getTextDocument(uri);
+    if (document) {
+      const stylesheet = this._languageService.parseStylesheet(document);
+      const diagnostics = this._languageService.doValidation(document, stylesheet);
+      return Promise.resolve(diagnostics);
+    }
+    return Promise.resolve([]);
+  }
+  async doComplete(uri, position) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const completions = this._languageService.doComplete(document, position, stylesheet);
+    return Promise.resolve(completions);
+  }
+  async doHover(uri, position) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const hover = this._languageService.doHover(document, position, stylesheet);
+    return Promise.resolve(hover);
+  }
+  async findDefinition(uri, position) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const definition = this._languageService.findDefinition(document, position, stylesheet);
+    return Promise.resolve(definition);
+  }
+  async findReferences(uri, position) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const references = this._languageService.findReferences(document, position, stylesheet);
+    return Promise.resolve(references);
+  }
+  async findDocumentHighlights(uri, position) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const highlights = this._languageService.findDocumentHighlights(document, position, stylesheet);
+    return Promise.resolve(highlights);
+  }
+  async findDocumentSymbols(uri) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const symbols = this._languageService.findDocumentSymbols(document, stylesheet);
+    return Promise.resolve(symbols);
+  }
+  async doCodeActions(uri, range, context) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const actions = this._languageService.doCodeActions(document, range, context, stylesheet);
+    return Promise.resolve(actions);
+  }
+  async findDocumentColors(uri) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const colorSymbols = this._languageService.findDocumentColors(document, stylesheet);
+    return Promise.resolve(colorSymbols);
+  }
+  async getColorPresentations(uri, color, range) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const colorPresentations = this._languageService.getColorPresentations(
+      document,
+      stylesheet,
+      color,
+      range
+    );
+    return Promise.resolve(colorPresentations);
+  }
+  async getFoldingRanges(uri, context) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const ranges = this._languageService.getFoldingRanges(document, context);
+    return Promise.resolve(ranges);
+  }
+  async getSelectionRanges(uri, positions) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const ranges = this._languageService.getSelectionRanges(document, positions, stylesheet);
+    return Promise.resolve(ranges);
+  }
+  async doRename(uri, position, newName) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const renames = this._languageService.doRename(document, position, newName, stylesheet);
+    return Promise.resolve(renames);
+  }
+  async format(uri, range, options) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const settings = { ...this._languageSettings.format, ...options };
+    const textEdits = this._languageService.format(document, range, settings);
+    return Promise.resolve(textEdits);
+  }
+  _getTextDocument(uri) {
+    const models = this._ctx.getMirrorModels();
+    for (const model of models) {
+      if (model.uri.toString() === uri) {
+        return TextDocument.create(
+          uri,
+          this._languageId,
+          model.version,
+          model.getValue()
+        );
+      }
+    }
+    return null;
+  }
+}
+
+export { CSSWorker };

package/dist/workers/language/html.worker.js

@@ -0,0 +1,8 @@
+import { initialize } from '../../common/initialize.js';
+import { HTMLWorker } from './htmlWorker.js';
+
+self.onmessage = () => {
+  initialize((ctx, createData) => {
+    return new HTMLWorker(ctx, createData);
+  });
+};