easy-email-pro-theme 0.2.0

package/lib/tsMode-934544e6.mjs

@@ -0,0 +1,1216 @@
+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 __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+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());
+  });
+};
+import { t as typescriptDefaults, m as monaco_editor_core_star } from "./VariablesEditorContent-08997e30.mjs";
+import "react";
+import "easy-email-pro-core";
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.36.1(6c56744c3419458f0dd48864520b759d1a3a1ca8)
+ * 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 __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField2 = (obj, key, value) => {
+  __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var monaco_editor_core_exports = {};
+__reExport(monaco_editor_core_exports, monaco_editor_core_star);
+var WorkerManager = class {
+  constructor(_modeId, _defaults) {
+    __publicField(this, "_configChangeListener");
+    __publicField(this, "_updateExtraLibsToken");
+    __publicField(this, "_extraLibsChangeListener");
+    __publicField(this, "_worker");
+    __publicField(this, "_client");
+    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({
+          moduleId: "vs/language/typescript/tsWorker",
+          label: this._modeId,
+          keepIdleModels: true,
+          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.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.es2017.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.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.full.d.ts"] = true;
+libFileSet["lib.es2020.intl.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.es5.d.ts"] = true;
+libFileSet["lib.es6.d.ts"] = true;
+libFileSet["lib.esnext.d.ts"] = true;
+libFileSet["lib.esnext.full.d.ts"] = true;
+libFileSet["lib.esnext.intl.d.ts"] = true;
+libFileSet["lib.esnext.promise.d.ts"] = true;
+libFileSet["lib.esnext.string.d.ts"] = true;
+libFileSet["lib.esnext.weakref.d.ts"] = true;
+libFileSet["lib.scripthost.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;
+  }
+  _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) {
+    __publicField(this, "_libFiles");
+    __publicField(this, "_hasFetchedLibFiles");
+    __publicField(this, "_fetchLibFilesPromise");
+    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);
+    __publicField(this, "_disposables", []);
+    __publicField(this, "_listener", /* @__PURE__ */ Object.create(null));
+    this._libFiles = _libFiles;
+    this._defaults = _defaults;
+    this._selector = _selector;
+    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 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 extends Adapter {
+  constructor() {
+    super(...arguments);
+    __publicField(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 OccurrencesAdapter = 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.getOccurrencesAtPosition(resource.toString(), offset);
+      if (!entries || model.isDisposed()) {
+        return;
+      }
+      return entries.map((entry) => {
+        return {
+          range: this._textSpanToRange(model, entry.textSpan),
+          kind: entry.isWriteAccess ? 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 items = yield worker.getNavigationBarItems(resource.toString());
+      if (!items || model.isDisposed()) {
+        return;
+      }
+      const convert = (bucket, item, containerLabel) => {
+        let 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: []
+        };
+        if (containerLabel)
+          result2.containerName = containerLabel;
+        if (item.childItems && item.childItems.length > 0) {
+          for (let child of item.childItems) {
+            convert(bucket, child, result2.name);
+          }
+        }
+        bucket.push(result2);
+      };
+      let result = [];
+      items.forEach((item) => convert(result, item));
+      return result;
+    });
+  }
+};
+var Kind = class {
+};
+__publicField2(Kind, "unknown", "");
+__publicField2(Kind, "keyword", "keyword");
+__publicField2(Kind, "script", "script");
+__publicField2(Kind, "module", "module");
+__publicField2(Kind, "class", "class");
+__publicField2(Kind, "interface", "interface");
+__publicField2(Kind, "type", "type");
+__publicField2(Kind, "enum", "enum");
+__publicField2(Kind, "variable", "var");
+__publicField2(Kind, "localVariable", "local var");
+__publicField2(Kind, "function", "function");
+__publicField2(Kind, "localFunction", "local function");
+__publicField2(Kind, "memberFunction", "method");
+__publicField2(Kind, "memberGetAccessor", "getter");
+__publicField2(Kind, "memberSetAccessor", "setter");
+__publicField2(Kind, "memberVariable", "property");
+__publicField2(Kind, "constructorImplementation", "constructor");
+__publicField2(Kind, "callSignature", "call");
+__publicField2(Kind, "indexSignature", "index");
+__publicField2(Kind, "constructSignature", "construct");
+__publicField2(Kind, "parameter", "parameter");
+__publicField2(Kind, "typeParameter", "type parameter");
+__publicField2(Kind, "primitiveType", "primitive type");
+__publicField2(Kind, "label", "label");
+__publicField2(Kind, "alias", "alias");
+__publicField2(Kind, "const", "const");
+__publicField2(Kind, "let", "let");
+__publicField2(Kind, "warning", "warning");
+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 {
+  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, false, false, 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 OccurrencesAdapter(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,
+  FormatAdapter,
+  FormatHelper,
+  FormatOnTypeAdapter,
+  InlayHintsAdapter,
+  Kind,
+  LibFiles,
+  OccurrencesAdapter,
+  OutlineAdapter,
+  QuickInfoAdapter,
+  ReferenceAdapter,
+  RenameAdapter,
+  SignatureHelpAdapter,
+  SuggestAdapter,
+  WorkerManager,
+  flattenDiagnosticMessageText,
+  getJavaScriptWorker,
+  getTypeScriptWorker,
+  setupJavaScript,
+  setupTypeScript
+};