markstream-vue2 0.0.45 → 0.0.46

package/dist/chunks/tsMode-4f227d36.js

@@ -1,1315 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-var _a;
-import { t as typescriptDefaults, m as monaco_editor_core_star } from "./index.legacy-010f0006.js";
-import "shiki";
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-var __defProp2 = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp2.call(to, key) && key !== except)
-        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var monaco_editor_core_exports = {};
-__reExport(monaco_editor_core_exports, monaco_editor_core_star);
-var WorkerManager = class {
-  constructor(_modeId, _defaults) {
-    this._modeId = _modeId;
-    this._defaults = _defaults;
-    this._worker = null;
-    this._client = null;
-    this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker());
-    this._updateExtraLibsToken = 0;
-    this._extraLibsChangeListener = this._defaults.onDidExtraLibsChange(
-      () => this._updateExtraLibs()
-    );
-  }
-  dispose() {
-    this._configChangeListener.dispose();
-    this._extraLibsChangeListener.dispose();
-    this._stopWorker();
-  }
-  _stopWorker() {
-    if (this._worker) {
-      this._worker.dispose();
-      this._worker = null;
-    }
-    this._client = null;
-  }
-  _updateExtraLibs() {
-    return __async(this, null, function* () {
-      if (!this._worker) {
-        return;
-      }
-      const myToken = ++this._updateExtraLibsToken;
-      const proxy = yield this._worker.getProxy();
-      if (this._updateExtraLibsToken !== myToken) {
-        return;
-      }
-      proxy.updateExtraLibs(this._defaults.getExtraLibs());
-    });
-  }
-  _getClient() {
-    if (!this._client) {
-      this._client = (() => __async(this, null, function* () {
-        this._worker = monaco_editor_core_exports.editor.createWebWorker({
-          // module that exports the create() method and returns a `TypeScriptWorker` instance
-          moduleId: "vs/language/typescript/tsWorker",
-          label: this._modeId,
-          keepIdleModels: true,
-          // passed in to the create() method
-          createData: {
-            compilerOptions: this._defaults.getCompilerOptions(),
-            extraLibs: this._defaults.getExtraLibs(),
-            customWorkerPath: this._defaults.workerOptions.customWorkerPath,
-            inlayHintsOptions: this._defaults.inlayHintsOptions
-          }
-        });
-        if (this._defaults.getEagerModelSync()) {
-          return yield this._worker.withSyncedResources(
-            monaco_editor_core_exports.editor.getModels().filter((model) => model.getLanguageId() === this._modeId).map((model) => model.uri)
-          );
-        }
-        return yield this._worker.getProxy();
-      }))();
-    }
-    return this._client;
-  }
-  getLanguageServiceWorker(...resources) {
-    return __async(this, null, function* () {
-      const client = yield this._getClient();
-      if (this._worker) {
-        yield this._worker.withSyncedResources(resources);
-      }
-      return client;
-    });
-  }
-};
-var libFileSet = {};
-libFileSet["lib.d.ts"] = true;
-libFileSet["lib.decorators.d.ts"] = true;
-libFileSet["lib.decorators.legacy.d.ts"] = true;
-libFileSet["lib.dom.asynciterable.d.ts"] = true;
-libFileSet["lib.dom.d.ts"] = true;
-libFileSet["lib.dom.iterable.d.ts"] = true;
-libFileSet["lib.es2015.collection.d.ts"] = true;
-libFileSet["lib.es2015.core.d.ts"] = true;
-libFileSet["lib.es2015.d.ts"] = true;
-libFileSet["lib.es2015.generator.d.ts"] = true;
-libFileSet["lib.es2015.iterable.d.ts"] = true;
-libFileSet["lib.es2015.promise.d.ts"] = true;
-libFileSet["lib.es2015.proxy.d.ts"] = true;
-libFileSet["lib.es2015.reflect.d.ts"] = true;
-libFileSet["lib.es2015.symbol.d.ts"] = true;
-libFileSet["lib.es2015.symbol.wellknown.d.ts"] = true;
-libFileSet["lib.es2016.array.include.d.ts"] = true;
-libFileSet["lib.es2016.d.ts"] = true;
-libFileSet["lib.es2016.full.d.ts"] = true;
-libFileSet["lib.es2016.intl.d.ts"] = true;
-libFileSet["lib.es2017.d.ts"] = true;
-libFileSet["lib.es2017.date.d.ts"] = true;
-libFileSet["lib.es2017.full.d.ts"] = true;
-libFileSet["lib.es2017.intl.d.ts"] = true;
-libFileSet["lib.es2017.object.d.ts"] = true;
-libFileSet["lib.es2017.sharedmemory.d.ts"] = true;
-libFileSet["lib.es2017.string.d.ts"] = true;
-libFileSet["lib.es2017.typedarrays.d.ts"] = true;
-libFileSet["lib.es2018.asyncgenerator.d.ts"] = true;
-libFileSet["lib.es2018.asynciterable.d.ts"] = true;
-libFileSet["lib.es2018.d.ts"] = true;
-libFileSet["lib.es2018.full.d.ts"] = true;
-libFileSet["lib.es2018.intl.d.ts"] = true;
-libFileSet["lib.es2018.promise.d.ts"] = true;
-libFileSet["lib.es2018.regexp.d.ts"] = true;
-libFileSet["lib.es2019.array.d.ts"] = true;
-libFileSet["lib.es2019.d.ts"] = true;
-libFileSet["lib.es2019.full.d.ts"] = true;
-libFileSet["lib.es2019.intl.d.ts"] = true;
-libFileSet["lib.es2019.object.d.ts"] = true;
-libFileSet["lib.es2019.string.d.ts"] = true;
-libFileSet["lib.es2019.symbol.d.ts"] = true;
-libFileSet["lib.es2020.bigint.d.ts"] = true;
-libFileSet["lib.es2020.d.ts"] = true;
-libFileSet["lib.es2020.date.d.ts"] = true;
-libFileSet["lib.es2020.full.d.ts"] = true;
-libFileSet["lib.es2020.intl.d.ts"] = true;
-libFileSet["lib.es2020.number.d.ts"] = true;
-libFileSet["lib.es2020.promise.d.ts"] = true;
-libFileSet["lib.es2020.sharedmemory.d.ts"] = true;
-libFileSet["lib.es2020.string.d.ts"] = true;
-libFileSet["lib.es2020.symbol.wellknown.d.ts"] = true;
-libFileSet["lib.es2021.d.ts"] = true;
-libFileSet["lib.es2021.full.d.ts"] = true;
-libFileSet["lib.es2021.intl.d.ts"] = true;
-libFileSet["lib.es2021.promise.d.ts"] = true;
-libFileSet["lib.es2021.string.d.ts"] = true;
-libFileSet["lib.es2021.weakref.d.ts"] = true;
-libFileSet["lib.es2022.array.d.ts"] = true;
-libFileSet["lib.es2022.d.ts"] = true;
-libFileSet["lib.es2022.error.d.ts"] = true;
-libFileSet["lib.es2022.full.d.ts"] = true;
-libFileSet["lib.es2022.intl.d.ts"] = true;
-libFileSet["lib.es2022.object.d.ts"] = true;
-libFileSet["lib.es2022.regexp.d.ts"] = true;
-libFileSet["lib.es2022.sharedmemory.d.ts"] = true;
-libFileSet["lib.es2022.string.d.ts"] = true;
-libFileSet["lib.es2023.array.d.ts"] = true;
-libFileSet["lib.es2023.collection.d.ts"] = true;
-libFileSet["lib.es2023.d.ts"] = true;
-libFileSet["lib.es2023.full.d.ts"] = true;
-libFileSet["lib.es5.d.ts"] = true;
-libFileSet["lib.es6.d.ts"] = true;
-libFileSet["lib.esnext.collection.d.ts"] = true;
-libFileSet["lib.esnext.d.ts"] = true;
-libFileSet["lib.esnext.decorators.d.ts"] = true;
-libFileSet["lib.esnext.disposable.d.ts"] = true;
-libFileSet["lib.esnext.full.d.ts"] = true;
-libFileSet["lib.esnext.intl.d.ts"] = true;
-libFileSet["lib.esnext.object.d.ts"] = true;
-libFileSet["lib.esnext.promise.d.ts"] = true;
-libFileSet["lib.scripthost.d.ts"] = true;
-libFileSet["lib.webworker.asynciterable.d.ts"] = true;
-libFileSet["lib.webworker.d.ts"] = true;
-libFileSet["lib.webworker.importscripts.d.ts"] = true;
-libFileSet["lib.webworker.iterable.d.ts"] = true;
-function flattenDiagnosticMessageText(diag, newLine, indent = 0) {
-  if (typeof diag === "string") {
-    return diag;
-  } else if (diag === void 0) {
-    return "";
-  }
-  let result = "";
-  if (indent) {
-    result += newLine;
-    for (let i = 0; i < indent; i++) {
-      result += "  ";
-    }
-  }
-  result += diag.messageText;
-  indent++;
-  if (diag.next) {
-    for (const kid of diag.next) {
-      result += flattenDiagnosticMessageText(kid, newLine, indent);
-    }
-  }
-  return result;
-}
-function displayPartsToString(displayParts) {
-  if (displayParts) {
-    return displayParts.map((displayPart) => displayPart.text).join("");
-  }
-  return "";
-}
-var Adapter = class {
-  constructor(_worker) {
-    this._worker = _worker;
-  }
-  // protected _positionToOffset(model: editor.ITextModel, position: monaco.IPosition): number {
-  // 	return model.getOffsetAt(position);
-  // }
-  // protected _offsetToPosition(model: editor.ITextModel, offset: number): monaco.IPosition {
-  // 	return model.getPositionAt(offset);
-  // }
-  _textSpanToRange(model, span) {
-    let p1 = model.getPositionAt(span.start);
-    let p2 = model.getPositionAt(span.start + span.length);
-    let { lineNumber: startLineNumber, column: startColumn } = p1;
-    let { lineNumber: endLineNumber, column: endColumn } = p2;
-    return { startLineNumber, startColumn, endLineNumber, endColumn };
-  }
-};
-var LibFiles = class {
-  constructor(_worker) {
-    this._worker = _worker;
-    this._libFiles = {};
-    this._hasFetchedLibFiles = false;
-    this._fetchLibFilesPromise = null;
-  }
-  isLibFile(uri) {
-    if (!uri) {
-      return false;
-    }
-    if (uri.path.indexOf("/lib.") === 0) {
-      return !!libFileSet[uri.path.slice(1)];
-    }
-    return false;
-  }
-  getOrCreateModel(fileName) {
-    const uri = monaco_editor_core_exports.Uri.parse(fileName);
-    const model = monaco_editor_core_exports.editor.getModel(uri);
-    if (model) {
-      return model;
-    }
-    if (this.isLibFile(uri) && this._hasFetchedLibFiles) {
-      return monaco_editor_core_exports.editor.createModel(this._libFiles[uri.path.slice(1)], "typescript", uri);
-    }
-    const matchedLibFile = typescriptDefaults.getExtraLibs()[fileName];
-    if (matchedLibFile) {
-      return monaco_editor_core_exports.editor.createModel(matchedLibFile.content, "typescript", uri);
-    }
-    return null;
-  }
-  _containsLibFile(uris) {
-    for (let uri of uris) {
-      if (this.isLibFile(uri)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  fetchLibFilesIfNecessary(uris) {
-    return __async(this, null, function* () {
-      if (!this._containsLibFile(uris)) {
-        return;
-      }
-      yield this._fetchLibFiles();
-    });
-  }
-  _fetchLibFiles() {
-    if (!this._fetchLibFilesPromise) {
-      this._fetchLibFilesPromise = this._worker().then((w) => w.getLibFiles()).then((libFiles) => {
-        this._hasFetchedLibFiles = true;
-        this._libFiles = libFiles;
-      });
-    }
-    return this._fetchLibFilesPromise;
-  }
-};
-var DiagnosticsAdapter = class extends Adapter {
-  constructor(_libFiles, _defaults, _selector, worker) {
-    super(worker);
-    this._libFiles = _libFiles;
-    this._defaults = _defaults;
-    this._selector = _selector;
-    this._disposables = [];
-    this._listener = /* @__PURE__ */ Object.create(null);
-    const onModelAdd = (model) => {
-      if (model.getLanguageId() !== _selector) {
-        return;
-      }
-      const maybeValidate = () => {
-        const { onlyVisible } = this._defaults.getDiagnosticsOptions();
-        if (onlyVisible) {
-          if (model.isAttachedToEditor()) {
-            this._doValidate(model);
-          }
-        } else {
-          this._doValidate(model);
-        }
-      };
-      let handle;
-      const changeSubscription = model.onDidChangeContent(() => {
-        clearTimeout(handle);
-        handle = window.setTimeout(maybeValidate, 500);
-      });
-      const visibleSubscription = model.onDidChangeAttached(() => {
-        const { onlyVisible } = this._defaults.getDiagnosticsOptions();
-        if (onlyVisible) {
-          if (model.isAttachedToEditor()) {
-            maybeValidate();
-          } else {
-            monaco_editor_core_exports.editor.setModelMarkers(model, this._selector, []);
-          }
-        }
-      });
-      this._listener[model.uri.toString()] = {
-        dispose() {
-          changeSubscription.dispose();
-          visibleSubscription.dispose();
-          clearTimeout(handle);
-        }
-      };
-      maybeValidate();
-    };
-    const onModelRemoved = (model) => {
-      monaco_editor_core_exports.editor.setModelMarkers(model, this._selector, []);
-      const key = model.uri.toString();
-      if (this._listener[key]) {
-        this._listener[key].dispose();
-        delete this._listener[key];
-      }
-    };
-    this._disposables.push(
-      monaco_editor_core_exports.editor.onDidCreateModel((model) => onModelAdd(model))
-    );
-    this._disposables.push(monaco_editor_core_exports.editor.onWillDisposeModel(onModelRemoved));
-    this._disposables.push(
-      monaco_editor_core_exports.editor.onDidChangeModelLanguage((event) => {
-        onModelRemoved(event.model);
-        onModelAdd(event.model);
-      })
-    );
-    this._disposables.push({
-      dispose() {
-        for (const model of monaco_editor_core_exports.editor.getModels()) {
-          onModelRemoved(model);
-        }
-      }
-    });
-    const recomputeDiagostics = () => {
-      for (const model of monaco_editor_core_exports.editor.getModels()) {
-        onModelRemoved(model);
-        onModelAdd(model);
-      }
-    };
-    this._disposables.push(this._defaults.onDidChange(recomputeDiagostics));
-    this._disposables.push(this._defaults.onDidExtraLibsChange(recomputeDiagostics));
-    monaco_editor_core_exports.editor.getModels().forEach((model) => onModelAdd(model));
-  }
-  dispose() {
-    this._disposables.forEach((d) => d && d.dispose());
-    this._disposables = [];
-  }
-  _doValidate(model) {
-    return __async(this, null, function* () {
-      const worker = yield this._worker(model.uri);
-      if (model.isDisposed()) {
-        return;
-      }
-      const promises = [];
-      const { noSyntaxValidation, noSemanticValidation, noSuggestionDiagnostics } = this._defaults.getDiagnosticsOptions();
-      if (!noSyntaxValidation) {
-        promises.push(worker.getSyntacticDiagnostics(model.uri.toString()));
-      }
-      if (!noSemanticValidation) {
-        promises.push(worker.getSemanticDiagnostics(model.uri.toString()));
-      }
-      if (!noSuggestionDiagnostics) {
-        promises.push(worker.getSuggestionDiagnostics(model.uri.toString()));
-      }
-      const allDiagnostics = yield Promise.all(promises);
-      if (!allDiagnostics || model.isDisposed()) {
-        return;
-      }
-      const diagnostics = allDiagnostics.reduce((p, c) => c.concat(p), []).filter(
-        (d) => (this._defaults.getDiagnosticsOptions().diagnosticCodesToIgnore || []).indexOf(d.code) === -1
-      );
-      const relatedUris = diagnostics.map((d) => d.relatedInformation || []).reduce((p, c) => c.concat(p), []).map(
-        (relatedInformation) => relatedInformation.file ? monaco_editor_core_exports.Uri.parse(relatedInformation.file.fileName) : null
-      );
-      yield this._libFiles.fetchLibFilesIfNecessary(relatedUris);
-      if (model.isDisposed()) {
-        return;
-      }
-      monaco_editor_core_exports.editor.setModelMarkers(
-        model,
-        this._selector,
-        diagnostics.map((d) => this._convertDiagnostics(model, d))
-      );
-    });
-  }
-  _convertDiagnostics(model, diag) {
-    const diagStart = diag.start || 0;
-    const diagLength = diag.length || 1;
-    const { lineNumber: startLineNumber, column: startColumn } = model.getPositionAt(diagStart);
-    const { lineNumber: endLineNumber, column: endColumn } = model.getPositionAt(
-      diagStart + diagLength
-    );
-    const tags = [];
-    if (diag.reportsUnnecessary) {
-      tags.push(monaco_editor_core_exports.MarkerTag.Unnecessary);
-    }
-    if (diag.reportsDeprecated) {
-      tags.push(monaco_editor_core_exports.MarkerTag.Deprecated);
-    }
-    return {
-      severity: this._tsDiagnosticCategoryToMarkerSeverity(diag.category),
-      startLineNumber,
-      startColumn,
-      endLineNumber,
-      endColumn,
-      message: flattenDiagnosticMessageText(diag.messageText, "\n"),
-      code: diag.code.toString(),
-      tags,
-      relatedInformation: this._convertRelatedInformation(model, diag.relatedInformation)
-    };
-  }
-  _convertRelatedInformation(model, relatedInformation) {
-    if (!relatedInformation) {
-      return [];
-    }
-    const result = [];
-    relatedInformation.forEach((info) => {
-      let relatedResource = model;
-      if (info.file) {
-        relatedResource = this._libFiles.getOrCreateModel(info.file.fileName);
-      }
-      if (!relatedResource) {
-        return;
-      }
-      const infoStart = info.start || 0;
-      const infoLength = info.length || 1;
-      const { lineNumber: startLineNumber, column: startColumn } = relatedResource.getPositionAt(infoStart);
-      const { lineNumber: endLineNumber, column: endColumn } = relatedResource.getPositionAt(
-        infoStart + infoLength
-      );
-      result.push({
-        resource: relatedResource.uri,
-        startLineNumber,
-        startColumn,
-        endLineNumber,
-        endColumn,
-        message: flattenDiagnosticMessageText(info.messageText, "\n")
-      });
-    });
-    return result;
-  }
-  _tsDiagnosticCategoryToMarkerSeverity(category) {
-    switch (category) {
-      case 1:
-        return monaco_editor_core_exports.MarkerSeverity.Error;
-      case 3:
-        return monaco_editor_core_exports.MarkerSeverity.Info;
-      case 0:
-        return monaco_editor_core_exports.MarkerSeverity.Warning;
-      case 2:
-        return monaco_editor_core_exports.MarkerSeverity.Hint;
-    }
-    return monaco_editor_core_exports.MarkerSeverity.Info;
-  }
-};
-var SuggestAdapter = class _SuggestAdapter extends Adapter {
-  get triggerCharacters() {
-    return ["."];
-  }
-  provideCompletionItems(model, position, _context, token) {
-    return __async(this, null, function* () {
-      const wordInfo = model.getWordUntilPosition(position);
-      const wordRange = new monaco_editor_core_exports.Range(
-        position.lineNumber,
-        wordInfo.startColumn,
-        position.lineNumber,
-        wordInfo.endColumn
-      );
-      const resource = model.uri;
-      const offset = model.getOffsetAt(position);
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return;
-      }
-      const info = yield worker.getCompletionsAtPosition(resource.toString(), offset);
-      if (!info || model.isDisposed()) {
-        return;
-      }
-      const suggestions = info.entries.map((entry) => {
-        let range = wordRange;
-        if (entry.replacementSpan) {
-          const p1 = model.getPositionAt(entry.replacementSpan.start);
-          const p2 = model.getPositionAt(entry.replacementSpan.start + entry.replacementSpan.length);
-          range = new monaco_editor_core_exports.Range(p1.lineNumber, p1.column, p2.lineNumber, p2.column);
-        }
-        const tags = [];
-        if (entry.kindModifiers !== void 0 && entry.kindModifiers.indexOf("deprecated") !== -1) {
-          tags.push(monaco_editor_core_exports.languages.CompletionItemTag.Deprecated);
-        }
-        return {
-          uri: resource,
-          position,
-          offset,
-          range,
-          label: entry.name,
-          insertText: entry.name,
-          sortText: entry.sortText,
-          kind: _SuggestAdapter.convertKind(entry.kind),
-          tags
-        };
-      });
-      return {
-        suggestions
-      };
-    });
-  }
-  resolveCompletionItem(item, token) {
-    return __async(this, null, function* () {
-      const myItem = item;
-      const resource = myItem.uri;
-      const position = myItem.position;
-      const offset = myItem.offset;
-      const worker = yield this._worker(resource);
-      const details = yield worker.getCompletionEntryDetails(
-        resource.toString(),
-        offset,
-        myItem.label
-      );
-      if (!details) {
-        return myItem;
-      }
-      return {
-        uri: resource,
-        position,
-        label: details.name,
-        kind: _SuggestAdapter.convertKind(details.kind),
-        detail: displayPartsToString(details.displayParts),
-        documentation: {
-          value: _SuggestAdapter.createDocumentationString(details)
-        }
-      };
-    });
-  }
-  static convertKind(kind) {
-    switch (kind) {
-      case Kind.primitiveType:
-      case Kind.keyword:
-        return monaco_editor_core_exports.languages.CompletionItemKind.Keyword;
-      case Kind.variable:
-      case Kind.localVariable:
-        return monaco_editor_core_exports.languages.CompletionItemKind.Variable;
-      case Kind.memberVariable:
-      case Kind.memberGetAccessor:
-      case Kind.memberSetAccessor:
-        return monaco_editor_core_exports.languages.CompletionItemKind.Field;
-      case Kind.function:
-      case Kind.memberFunction:
-      case Kind.constructSignature:
-      case Kind.callSignature:
-      case Kind.indexSignature:
-        return monaco_editor_core_exports.languages.CompletionItemKind.Function;
-      case Kind.enum:
-        return monaco_editor_core_exports.languages.CompletionItemKind.Enum;
-      case Kind.module:
-        return monaco_editor_core_exports.languages.CompletionItemKind.Module;
-      case Kind.class:
-        return monaco_editor_core_exports.languages.CompletionItemKind.Class;
-      case Kind.interface:
-        return monaco_editor_core_exports.languages.CompletionItemKind.Interface;
-      case Kind.warning:
-        return monaco_editor_core_exports.languages.CompletionItemKind.File;
-    }
-    return monaco_editor_core_exports.languages.CompletionItemKind.Property;
-  }
-  static createDocumentationString(details) {
-    let documentationString = displayPartsToString(details.documentation);
-    if (details.tags) {
-      for (const tag of details.tags) {
-        documentationString += `
-
-${tagToString(tag)}`;
-      }
-    }
-    return documentationString;
-  }
-};
-function tagToString(tag) {
-  let tagLabel = `*@${tag.name}*`;
-  if (tag.name === "param" && tag.text) {
-    const [paramName, ...rest] = tag.text;
-    tagLabel += `\`${paramName.text}\``;
-    if (rest.length > 0)
-      tagLabel += ` — ${rest.map((r) => r.text).join(" ")}`;
-  } else if (Array.isArray(tag.text)) {
-    tagLabel += ` — ${tag.text.map((r) => r.text).join(" ")}`;
-  } else if (tag.text) {
-    tagLabel += ` — ${tag.text}`;
-  }
-  return tagLabel;
-}
-var SignatureHelpAdapter = class _SignatureHelpAdapter extends Adapter {
-  constructor() {
-    super(...arguments);
-    this.signatureHelpTriggerCharacters = ["(", ","];
-  }
-  static _toSignatureHelpTriggerReason(context) {
-    switch (context.triggerKind) {
-      case monaco_editor_core_exports.languages.SignatureHelpTriggerKind.TriggerCharacter:
-        if (context.triggerCharacter) {
-          if (context.isRetrigger) {
-            return { kind: "retrigger", triggerCharacter: context.triggerCharacter };
-          } else {
-            return { kind: "characterTyped", triggerCharacter: context.triggerCharacter };
-          }
-        } else {
-          return { kind: "invoked" };
-        }
-      case monaco_editor_core_exports.languages.SignatureHelpTriggerKind.ContentChange:
-        return context.isRetrigger ? { kind: "retrigger" } : { kind: "invoked" };
-      case monaco_editor_core_exports.languages.SignatureHelpTriggerKind.Invoke:
-      default:
-        return { kind: "invoked" };
-    }
-  }
-  provideSignatureHelp(model, position, token, context) {
-    return __async(this, null, function* () {
-      const resource = model.uri;
-      const offset = model.getOffsetAt(position);
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return;
-      }
-      const info = yield worker.getSignatureHelpItems(resource.toString(), offset, {
-        triggerReason: _SignatureHelpAdapter._toSignatureHelpTriggerReason(context)
-      });
-      if (!info || model.isDisposed()) {
-        return;
-      }
-      const ret = {
-        activeSignature: info.selectedItemIndex,
-        activeParameter: info.argumentIndex,
-        signatures: []
-      };
-      info.items.forEach((item) => {
-        const signature = {
-          label: "",
-          parameters: []
-        };
-        signature.documentation = {
-          value: displayPartsToString(item.documentation)
-        };
-        signature.label += displayPartsToString(item.prefixDisplayParts);
-        item.parameters.forEach((p, i, a) => {
-          const label = displayPartsToString(p.displayParts);
-          const parameter = {
-            label,
-            documentation: {
-              value: displayPartsToString(p.documentation)
-            }
-          };
-          signature.label += label;
-          signature.parameters.push(parameter);
-          if (i < a.length - 1) {
-            signature.label += displayPartsToString(item.separatorDisplayParts);
-          }
-        });
-        signature.label += displayPartsToString(item.suffixDisplayParts);
-        ret.signatures.push(signature);
-      });
-      return {
-        value: ret,
-        dispose() {
-        }
-      };
-    });
-  }
-};
-var QuickInfoAdapter = class extends Adapter {
-  provideHover(model, position, token) {
-    return __async(this, null, function* () {
-      const resource = model.uri;
-      const offset = model.getOffsetAt(position);
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return;
-      }
-      const info = yield worker.getQuickInfoAtPosition(resource.toString(), offset);
-      if (!info || model.isDisposed()) {
-        return;
-      }
-      const documentation = displayPartsToString(info.documentation);
-      const tags = info.tags ? info.tags.map((tag) => tagToString(tag)).join("  \n\n") : "";
-      const contents = displayPartsToString(info.displayParts);
-      return {
-        range: this._textSpanToRange(model, info.textSpan),
-        contents: [
-          {
-            value: "```typescript\n" + contents + "\n```\n"
-          },
-          {
-            value: documentation + (tags ? "\n\n" + tags : "")
-          }
-        ]
-      };
-    });
-  }
-};
-var DocumentHighlightAdapter = class extends Adapter {
-  provideDocumentHighlights(model, position, token) {
-    return __async(this, null, function* () {
-      const resource = model.uri;
-      const offset = model.getOffsetAt(position);
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return;
-      }
-      const entries = yield worker.getDocumentHighlights(resource.toString(), offset, [
-        resource.toString()
-      ]);
-      if (!entries || model.isDisposed()) {
-        return;
-      }
-      return entries.flatMap((entry) => {
-        return entry.highlightSpans.map((highlightSpans) => {
-          return {
-            range: this._textSpanToRange(model, highlightSpans.textSpan),
-            kind: highlightSpans.kind === "writtenReference" ? monaco_editor_core_exports.languages.DocumentHighlightKind.Write : monaco_editor_core_exports.languages.DocumentHighlightKind.Text
-          };
-        });
-      });
-    });
-  }
-};
-var DefinitionAdapter = class extends Adapter {
-  constructor(_libFiles, worker) {
-    super(worker);
-    this._libFiles = _libFiles;
-  }
-  provideDefinition(model, position, token) {
-    return __async(this, null, function* () {
-      const resource = model.uri;
-      const offset = model.getOffsetAt(position);
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return;
-      }
-      const entries = yield worker.getDefinitionAtPosition(resource.toString(), offset);
-      if (!entries || model.isDisposed()) {
-        return;
-      }
-      yield this._libFiles.fetchLibFilesIfNecessary(
-        entries.map((entry) => monaco_editor_core_exports.Uri.parse(entry.fileName))
-      );
-      if (model.isDisposed()) {
-        return;
-      }
-      const result = [];
-      for (let entry of entries) {
-        const refModel = this._libFiles.getOrCreateModel(entry.fileName);
-        if (refModel) {
-          result.push({
-            uri: refModel.uri,
-            range: this._textSpanToRange(refModel, entry.textSpan)
-          });
-        }
-      }
-      return result;
-    });
-  }
-};
-var ReferenceAdapter = class extends Adapter {
-  constructor(_libFiles, worker) {
-    super(worker);
-    this._libFiles = _libFiles;
-  }
-  provideReferences(model, position, context, token) {
-    return __async(this, null, function* () {
-      const resource = model.uri;
-      const offset = model.getOffsetAt(position);
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return;
-      }
-      const entries = yield worker.getReferencesAtPosition(resource.toString(), offset);
-      if (!entries || model.isDisposed()) {
-        return;
-      }
-      yield this._libFiles.fetchLibFilesIfNecessary(
-        entries.map((entry) => monaco_editor_core_exports.Uri.parse(entry.fileName))
-      );
-      if (model.isDisposed()) {
-        return;
-      }
-      const result = [];
-      for (let entry of entries) {
-        const refModel = this._libFiles.getOrCreateModel(entry.fileName);
-        if (refModel) {
-          result.push({
-            uri: refModel.uri,
-            range: this._textSpanToRange(refModel, entry.textSpan)
-          });
-        }
-      }
-      return result;
-    });
-  }
-};
-var OutlineAdapter = class extends Adapter {
-  provideDocumentSymbols(model, token) {
-    return __async(this, null, function* () {
-      const resource = model.uri;
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return;
-      }
-      const root = yield worker.getNavigationTree(resource.toString());
-      if (!root || model.isDisposed()) {
-        return;
-      }
-      const convert = (item, containerLabel) => {
-        var _a2;
-        const result2 = {
-          name: item.text,
-          detail: "",
-          kind: outlineTypeTable[item.kind] || monaco_editor_core_exports.languages.SymbolKind.Variable,
-          range: this._textSpanToRange(model, item.spans[0]),
-          selectionRange: this._textSpanToRange(model, item.spans[0]),
-          tags: [],
-          children: (_a2 = item.childItems) == null ? void 0 : _a2.map((child) => convert(child, item.text)),
-          containerName: containerLabel
-        };
-        return result2;
-      };
-      const result = root.childItems ? root.childItems.map((item) => convert(item)) : [];
-      return result;
-    });
-  }
-};
-var Kind = (_a = class {
-}, _a.unknown = "", _a.keyword = "keyword", _a.script = "script", _a.module = "module", _a.class = "class", _a.interface = "interface", _a.type = "type", _a.enum = "enum", _a.variable = "var", _a.localVariable = "local var", _a.function = "function", _a.localFunction = "local function", _a.memberFunction = "method", _a.memberGetAccessor = "getter", _a.memberSetAccessor = "setter", _a.memberVariable = "property", _a.constructorImplementation = "constructor", _a.callSignature = "call", _a.indexSignature = "index", _a.constructSignature = "construct", _a.parameter = "parameter", _a.typeParameter = "type parameter", _a.primitiveType = "primitive type", _a.label = "label", _a.alias = "alias", _a.const = "const", _a.let = "let", _a.warning = "warning", _a);
-var outlineTypeTable = /* @__PURE__ */ Object.create(null);
-outlineTypeTable[Kind.module] = monaco_editor_core_exports.languages.SymbolKind.Module;
-outlineTypeTable[Kind.class] = monaco_editor_core_exports.languages.SymbolKind.Class;
-outlineTypeTable[Kind.enum] = monaco_editor_core_exports.languages.SymbolKind.Enum;
-outlineTypeTable[Kind.interface] = monaco_editor_core_exports.languages.SymbolKind.Interface;
-outlineTypeTable[Kind.memberFunction] = monaco_editor_core_exports.languages.SymbolKind.Method;
-outlineTypeTable[Kind.memberVariable] = monaco_editor_core_exports.languages.SymbolKind.Property;
-outlineTypeTable[Kind.memberGetAccessor] = monaco_editor_core_exports.languages.SymbolKind.Property;
-outlineTypeTable[Kind.memberSetAccessor] = monaco_editor_core_exports.languages.SymbolKind.Property;
-outlineTypeTable[Kind.variable] = monaco_editor_core_exports.languages.SymbolKind.Variable;
-outlineTypeTable[Kind.const] = monaco_editor_core_exports.languages.SymbolKind.Variable;
-outlineTypeTable[Kind.localVariable] = monaco_editor_core_exports.languages.SymbolKind.Variable;
-outlineTypeTable[Kind.variable] = monaco_editor_core_exports.languages.SymbolKind.Variable;
-outlineTypeTable[Kind.function] = monaco_editor_core_exports.languages.SymbolKind.Function;
-outlineTypeTable[Kind.localFunction] = monaco_editor_core_exports.languages.SymbolKind.Function;
-var FormatHelper = class extends Adapter {
-  static _convertOptions(options) {
-    return {
-      ConvertTabsToSpaces: options.insertSpaces,
-      TabSize: options.tabSize,
-      IndentSize: options.tabSize,
-      IndentStyle: 2,
-      NewLineCharacter: "\n",
-      InsertSpaceAfterCommaDelimiter: true,
-      InsertSpaceAfterSemicolonInForStatements: true,
-      InsertSpaceBeforeAndAfterBinaryOperators: true,
-      InsertSpaceAfterKeywordsInControlFlowStatements: true,
-      InsertSpaceAfterFunctionKeywordForAnonymousFunctions: true,
-      InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
-      InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
-      InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
-      PlaceOpenBraceOnNewLineForControlBlocks: false,
-      PlaceOpenBraceOnNewLineForFunctions: false
-    };
-  }
-  _convertTextChanges(model, change) {
-    return {
-      text: change.newText,
-      range: this._textSpanToRange(model, change.span)
-    };
-  }
-};
-var FormatAdapter = class extends FormatHelper {
-  constructor() {
-    super(...arguments);
-    this.canFormatMultipleRanges = false;
-  }
-  provideDocumentRangeFormattingEdits(model, range, options, token) {
-    return __async(this, null, function* () {
-      const resource = model.uri;
-      const startOffset = model.getOffsetAt({
-        lineNumber: range.startLineNumber,
-        column: range.startColumn
-      });
-      const endOffset = model.getOffsetAt({
-        lineNumber: range.endLineNumber,
-        column: range.endColumn
-      });
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return;
-      }
-      const edits = yield worker.getFormattingEditsForRange(
-        resource.toString(),
-        startOffset,
-        endOffset,
-        FormatHelper._convertOptions(options)
-      );
-      if (!edits || model.isDisposed()) {
-        return;
-      }
-      return edits.map((edit) => this._convertTextChanges(model, edit));
-    });
-  }
-};
-var FormatOnTypeAdapter = class extends FormatHelper {
-  get autoFormatTriggerCharacters() {
-    return [";", "}", "\n"];
-  }
-  provideOnTypeFormattingEdits(model, position, ch, options, token) {
-    return __async(this, null, function* () {
-      const resource = model.uri;
-      const offset = model.getOffsetAt(position);
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return;
-      }
-      const edits = yield worker.getFormattingEditsAfterKeystroke(
-        resource.toString(),
-        offset,
-        ch,
-        FormatHelper._convertOptions(options)
-      );
-      if (!edits || model.isDisposed()) {
-        return;
-      }
-      return edits.map((edit) => this._convertTextChanges(model, edit));
-    });
-  }
-};
-var CodeActionAdaptor = class extends FormatHelper {
-  provideCodeActions(model, range, context, token) {
-    return __async(this, null, function* () {
-      const resource = model.uri;
-      const start = model.getOffsetAt({
-        lineNumber: range.startLineNumber,
-        column: range.startColumn
-      });
-      const end = model.getOffsetAt({
-        lineNumber: range.endLineNumber,
-        column: range.endColumn
-      });
-      const formatOptions = FormatHelper._convertOptions(model.getOptions());
-      const errorCodes = context.markers.filter((m) => m.code).map((m) => m.code).map(Number);
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return;
-      }
-      const codeFixes = yield worker.getCodeFixesAtPosition(
-        resource.toString(),
-        start,
-        end,
-        errorCodes,
-        formatOptions
-      );
-      if (!codeFixes || model.isDisposed()) {
-        return { actions: [], dispose: () => {
-        } };
-      }
-      const actions = codeFixes.filter((fix) => {
-        return fix.changes.filter((change) => change.isNewFile).length === 0;
-      }).map((fix) => {
-        return this._tsCodeFixActionToMonacoCodeAction(model, context, fix);
-      });
-      return {
-        actions,
-        dispose: () => {
-        }
-      };
-    });
-  }
-  _tsCodeFixActionToMonacoCodeAction(model, context, codeFix) {
-    const edits = [];
-    for (const change of codeFix.changes) {
-      for (const textChange of change.textChanges) {
-        edits.push({
-          resource: model.uri,
-          versionId: void 0,
-          textEdit: {
-            range: this._textSpanToRange(model, textChange.span),
-            text: textChange.newText
-          }
-        });
-      }
-    }
-    const action = {
-      title: codeFix.description,
-      edit: { edits },
-      diagnostics: context.markers,
-      kind: "quickfix"
-    };
-    return action;
-  }
-};
-var RenameAdapter = class extends Adapter {
-  constructor(_libFiles, worker) {
-    super(worker);
-    this._libFiles = _libFiles;
-  }
-  provideRenameEdits(model, position, newName, token) {
-    return __async(this, null, function* () {
-      const resource = model.uri;
-      const fileName = resource.toString();
-      const offset = model.getOffsetAt(position);
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return;
-      }
-      const renameInfo = yield worker.getRenameInfo(fileName, offset, {
-        allowRenameOfImportPath: false
-      });
-      if (renameInfo.canRename === false) {
-        return {
-          edits: [],
-          rejectReason: renameInfo.localizedErrorMessage
-        };
-      }
-      if (renameInfo.fileToRename !== void 0) {
-        throw new Error("Renaming files is not supported.");
-      }
-      const renameLocations = yield worker.findRenameLocations(
-        fileName,
-        offset,
-        /*strings*/
-        false,
-        /*comments*/
-        false,
-        /*prefixAndSuffix*/
-        false
-      );
-      if (!renameLocations || model.isDisposed()) {
-        return;
-      }
-      const edits = [];
-      for (const renameLocation of renameLocations) {
-        const model2 = this._libFiles.getOrCreateModel(renameLocation.fileName);
-        if (model2) {
-          edits.push({
-            resource: model2.uri,
-            versionId: void 0,
-            textEdit: {
-              range: this._textSpanToRange(model2, renameLocation.textSpan),
-              text: newName
-            }
-          });
-        } else {
-          throw new Error(`Unknown file ${renameLocation.fileName}.`);
-        }
-      }
-      return { edits };
-    });
-  }
-};
-var InlayHintsAdapter = class extends Adapter {
-  provideInlayHints(model, range, token) {
-    return __async(this, null, function* () {
-      const resource = model.uri;
-      const fileName = resource.toString();
-      const start = model.getOffsetAt({
-        lineNumber: range.startLineNumber,
-        column: range.startColumn
-      });
-      const end = model.getOffsetAt({
-        lineNumber: range.endLineNumber,
-        column: range.endColumn
-      });
-      const worker = yield this._worker(resource);
-      if (model.isDisposed()) {
-        return null;
-      }
-      const tsHints = yield worker.provideInlayHints(fileName, start, end);
-      const hints = tsHints.map((hint) => {
-        return __spreadProps(__spreadValues({}, hint), {
-          label: hint.text,
-          position: model.getPositionAt(hint.position),
-          kind: this._convertHintKind(hint.kind)
-        });
-      });
-      return { hints, dispose: () => {
-      } };
-    });
-  }
-  _convertHintKind(kind) {
-    switch (kind) {
-      case "Parameter":
-        return monaco_editor_core_exports.languages.InlayHintKind.Parameter;
-      case "Type":
-        return monaco_editor_core_exports.languages.InlayHintKind.Type;
-      default:
-        return monaco_editor_core_exports.languages.InlayHintKind.Type;
-    }
-  }
-};
-var javaScriptWorker;
-var typeScriptWorker;
-function setupTypeScript(defaults) {
-  typeScriptWorker = setupMode(defaults, "typescript");
-}
-function setupJavaScript(defaults) {
-  javaScriptWorker = setupMode(defaults, "javascript");
-}
-function getJavaScriptWorker() {
-  return new Promise((resolve, reject) => {
-    if (!javaScriptWorker) {
-      return reject("JavaScript not registered!");
-    }
-    resolve(javaScriptWorker);
-  });
-}
-function getTypeScriptWorker() {
-  return new Promise((resolve, reject) => {
-    if (!typeScriptWorker) {
-      return reject("TypeScript not registered!");
-    }
-    resolve(typeScriptWorker);
-  });
-}
-function setupMode(defaults, modeId) {
-  const providers = [];
-  const client = new WorkerManager(modeId, defaults);
-  const worker = (...uris) => {
-    return client.getLanguageServiceWorker(...uris);
-  };
-  const libFiles = new LibFiles(worker);
-  function registerProviders() {
-    const { modeConfiguration } = defaults;
-    disposeAll(providers);
-    if (modeConfiguration.completionItems) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerCompletionItemProvider(
-          modeId,
-          new SuggestAdapter(worker)
-        )
-      );
-    }
-    if (modeConfiguration.signatureHelp) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerSignatureHelpProvider(
-          modeId,
-          new SignatureHelpAdapter(worker)
-        )
-      );
-    }
-    if (modeConfiguration.hovers) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerHoverProvider(modeId, new QuickInfoAdapter(worker))
-      );
-    }
-    if (modeConfiguration.documentHighlights) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerDocumentHighlightProvider(
-          modeId,
-          new DocumentHighlightAdapter(worker)
-        )
-      );
-    }
-    if (modeConfiguration.definitions) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerDefinitionProvider(
-          modeId,
-          new DefinitionAdapter(libFiles, worker)
-        )
-      );
-    }
-    if (modeConfiguration.references) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerReferenceProvider(
-          modeId,
-          new ReferenceAdapter(libFiles, worker)
-        )
-      );
-    }
-    if (modeConfiguration.documentSymbols) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerDocumentSymbolProvider(
-          modeId,
-          new OutlineAdapter(worker)
-        )
-      );
-    }
-    if (modeConfiguration.rename) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerRenameProvider(
-          modeId,
-          new RenameAdapter(libFiles, worker)
-        )
-      );
-    }
-    if (modeConfiguration.documentRangeFormattingEdits) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerDocumentRangeFormattingEditProvider(
-          modeId,
-          new FormatAdapter(worker)
-        )
-      );
-    }
-    if (modeConfiguration.onTypeFormattingEdits) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerOnTypeFormattingEditProvider(
-          modeId,
-          new FormatOnTypeAdapter(worker)
-        )
-      );
-    }
-    if (modeConfiguration.codeActions) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerCodeActionProvider(modeId, new CodeActionAdaptor(worker))
-      );
-    }
-    if (modeConfiguration.inlayHints) {
-      providers.push(
-        monaco_editor_core_exports.languages.registerInlayHintsProvider(modeId, new InlayHintsAdapter(worker))
-      );
-    }
-    if (modeConfiguration.diagnostics) {
-      providers.push(new DiagnosticsAdapter(libFiles, defaults, modeId, worker));
-    }
-  }
-  registerProviders();
-  return worker;
-}
-function disposeAll(disposables) {
-  while (disposables.length) {
-    disposables.pop().dispose();
-  }
-}
-export {
-  Adapter,
-  CodeActionAdaptor,
-  DefinitionAdapter,
-  DiagnosticsAdapter,
-  DocumentHighlightAdapter,
-  FormatAdapter,
-  FormatHelper,
-  FormatOnTypeAdapter,
-  InlayHintsAdapter,
-  Kind,
-  LibFiles,
-  OutlineAdapter,
-  QuickInfoAdapter,
-  ReferenceAdapter,
-  RenameAdapter,
-  SignatureHelpAdapter,
-  SuggestAdapter,
-  WorkerManager,
-  flattenDiagnosticMessageText,
-  getJavaScriptWorker,
-  getTypeScriptWorker,
-  setupJavaScript,
-  setupTypeScript
-};