@univerjs/uniscript 0.4.0-alpha.0 → 0.4.0-alpha.1

package/lib/tsMode-BB2mDc5d.mjs

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