modern-monaco 0.0.0-beta.0

package/dist/lsp/typescript/worker.js

@@ -0,0 +1,2858 @@
+// node_modules/.pnpm/@esm.sh+import-map@0.1.1/node_modules/@esm.sh/import-map/dist/import-map.mjs
+function resolve(importMap, specifier, containingFile) {
+  const { $baseURL, imports, scopes } = importMap;
+  const { origin, pathname } = new URL(containingFile, $baseURL);
+  const sameOriginScopes = [];
+  for (const scopeName in scopes) {
+    const scopeUrl = new URL(scopeName, $baseURL);
+    if (scopeUrl.origin === origin) {
+      sameOriginScopes.push([scopeUrl.pathname, scopes[scopeName]]);
+    }
+  }
+  sameOriginScopes.sort(([a], [b]) => b.split("/").length - a.split("/").length);
+  if (sameOriginScopes.length > 0) {
+    for (const [scopePathname, scopeImports] of sameOriginScopes) {
+      if (pathname.startsWith(scopePathname)) {
+        const url = matchImport(specifier, scopeImports);
+        if (url) {
+          return [url, true];
+        }
+      }
+    }
+  }
+  if (origin === new URL($baseURL).origin) {
+    const url = matchImport(specifier, imports);
+    if (url) {
+      return [url, true];
+    }
+  }
+  return [specifier, false];
+}
+function isBlankImportMap(importMap) {
+  const { imports, scopes } = importMap;
+  if (isObject(imports) && Object.keys(imports).length > 0 || isObject(scopes) && Object.keys(scopes).length > 0) {
+    return false;
+  }
+  return true;
+}
+function matchImport(specifier, imports) {
+  if (specifier in imports) {
+    return imports[specifier];
+  }
+  for (const [k, v] of Object.entries(imports)) {
+    if (k.endsWith("/")) {
+      if (specifier.startsWith(k)) {
+        return v + specifier.slice(k.length);
+      }
+    } else if (specifier.startsWith(k + "/")) {
+      return v + specifier.slice(k.length);
+    }
+  }
+  return null;
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+// src/lsp/typescript/worker.ts
+import ts from "typescript";
+
+// node_modules/.pnpm/vscode-languageserver-types@3.17.5/node_modules/vscode-languageserver-types/lib/esm/main.js
+var DocumentUri;
+(function(DocumentUri2) {
+  function is(value) {
+    return typeof value === "string";
+  }
+  DocumentUri2.is = is;
+})(DocumentUri || (DocumentUri = {}));
+var URI;
+(function(URI2) {
+  function is(value) {
+    return typeof value === "string";
+  }
+  URI2.is = is;
+})(URI || (URI = {}));
+var integer;
+(function(integer2) {
+  integer2.MIN_VALUE = -2147483648;
+  integer2.MAX_VALUE = 2147483647;
+  function is(value) {
+    return typeof value === "number" && integer2.MIN_VALUE <= value && value <= integer2.MAX_VALUE;
+  }
+  integer2.is = is;
+})(integer || (integer = {}));
+var uinteger;
+(function(uinteger2) {
+  uinteger2.MIN_VALUE = 0;
+  uinteger2.MAX_VALUE = 2147483647;
+  function is(value) {
+    return typeof value === "number" && uinteger2.MIN_VALUE <= value && value <= uinteger2.MAX_VALUE;
+  }
+  uinteger2.is = is;
+})(uinteger || (uinteger = {}));
+var Position;
+(function(Position2) {
+  function create(line, character) {
+    if (line === Number.MAX_VALUE) {
+      line = uinteger.MAX_VALUE;
+    }
+    if (character === Number.MAX_VALUE) {
+      character = uinteger.MAX_VALUE;
+    }
+    return { line, character };
+  }
+  Position2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
+  }
+  Position2.is = is;
+})(Position || (Position = {}));
+var Range;
+(function(Range2) {
+  function create(one, two, three, four) {
+    if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
+      return { start: Position.create(one, two), end: Position.create(three, four) };
+    } else if (Position.is(one) && Position.is(two)) {
+      return { start: one, end: two };
+    } else {
+      throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
+    }
+  }
+  Range2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);
+  }
+  Range2.is = is;
+})(Range || (Range = {}));
+var Location;
+(function(Location2) {
+  function create(uri, range) {
+    return { uri, range };
+  }
+  Location2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.objectLiteral(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
+  }
+  Location2.is = is;
+})(Location || (Location = {}));
+var LocationLink;
+(function(LocationLink2) {
+  function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
+    return { targetUri, targetRange, targetSelectionRange, originSelectionRange };
+  }
+  LocationLink2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.objectLiteral(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri) && Range.is(candidate.targetSelectionRange) && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
+  }
+  LocationLink2.is = is;
+})(LocationLink || (LocationLink = {}));
+var Color;
+(function(Color2) {
+  function create(red, green, blue, alpha) {
+    return {
+      red,
+      green,
+      blue,
+      alpha
+    };
+  }
+  Color2.create = create;
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(candidate) && Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
+  }
+  Color2.is = is;
+})(Color || (Color = {}));
+var ColorInformation;
+(function(ColorInformation2) {
+  function create(range, color) {
+    return {
+      range,
+      color
+    };
+  }
+  ColorInformation2.create = create;
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(candidate) && Range.is(candidate.range) && Color.is(candidate.color);
+  }
+  ColorInformation2.is = is;
+})(ColorInformation || (ColorInformation = {}));
+var ColorPresentation;
+(function(ColorPresentation2) {
+  function create(label, textEdit, additionalTextEdits) {
+    return {
+      label,
+      textEdit,
+      additionalTextEdits
+    };
+  }
+  ColorPresentation2.create = create;
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate)) && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
+  }
+  ColorPresentation2.is = is;
+})(ColorPresentation || (ColorPresentation = {}));
+var FoldingRangeKind;
+(function(FoldingRangeKind2) {
+  FoldingRangeKind2.Comment = "comment";
+  FoldingRangeKind2.Imports = "imports";
+  FoldingRangeKind2.Region = "region";
+})(FoldingRangeKind || (FoldingRangeKind = {}));
+var FoldingRange;
+(function(FoldingRange2) {
+  function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {
+    const result = {
+      startLine,
+      endLine
+    };
+    if (Is.defined(startCharacter)) {
+      result.startCharacter = startCharacter;
+    }
+    if (Is.defined(endCharacter)) {
+      result.endCharacter = endCharacter;
+    }
+    if (Is.defined(kind)) {
+      result.kind = kind;
+    }
+    if (Is.defined(collapsedText)) {
+      result.collapsedText = collapsedText;
+    }
+    return result;
+  }
+  FoldingRange2.create = create;
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
+  }
+  FoldingRange2.is = is;
+})(FoldingRange || (FoldingRange = {}));
+var DiagnosticRelatedInformation;
+(function(DiagnosticRelatedInformation2) {
+  function create(location, message) {
+    return {
+      location,
+      message
+    };
+  }
+  DiagnosticRelatedInformation2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
+  }
+  DiagnosticRelatedInformation2.is = is;
+})(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
+var DiagnosticSeverity;
+(function(DiagnosticSeverity2) {
+  DiagnosticSeverity2.Error = 1;
+  DiagnosticSeverity2.Warning = 2;
+  DiagnosticSeverity2.Information = 3;
+  DiagnosticSeverity2.Hint = 4;
+})(DiagnosticSeverity || (DiagnosticSeverity = {}));
+var DiagnosticTag;
+(function(DiagnosticTag2) {
+  DiagnosticTag2.Unnecessary = 1;
+  DiagnosticTag2.Deprecated = 2;
+})(DiagnosticTag || (DiagnosticTag = {}));
+var CodeDescription;
+(function(CodeDescription2) {
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(candidate) && Is.string(candidate.href);
+  }
+  CodeDescription2.is = is;
+})(CodeDescription || (CodeDescription = {}));
+var Diagnostic;
+(function(Diagnostic2) {
+  function create(range, message, severity, code, source, relatedInformation) {
+    let result = { range, message };
+    if (Is.defined(severity)) {
+      result.severity = severity;
+    }
+    if (Is.defined(code)) {
+      result.code = code;
+    }
+    if (Is.defined(source)) {
+      result.source = source;
+    }
+    if (Is.defined(relatedInformation)) {
+      result.relatedInformation = relatedInformation;
+    }
+    return result;
+  }
+  Diagnostic2.create = create;
+  function is(value) {
+    var _a;
+    let candidate = value;
+    return Is.defined(candidate) && Range.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
+  }
+  Diagnostic2.is = is;
+})(Diagnostic || (Diagnostic = {}));
+var Command;
+(function(Command2) {
+  function create(title, command, ...args) {
+    let result = { title, command };
+    if (Is.defined(args) && args.length > 0) {
+      result.arguments = args;
+    }
+    return result;
+  }
+  Command2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
+  }
+  Command2.is = is;
+})(Command || (Command = {}));
+var TextEdit;
+(function(TextEdit2) {
+  function replace(range, newText) {
+    return { range, newText };
+  }
+  TextEdit2.replace = replace;
+  function insert(position, newText) {
+    return { range: { start: position, end: position }, newText };
+  }
+  TextEdit2.insert = insert;
+  function del(range) {
+    return { range, newText: "" };
+  }
+  TextEdit2.del = del;
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range.is(candidate.range);
+  }
+  TextEdit2.is = is;
+})(TextEdit || (TextEdit = {}));
+var ChangeAnnotation;
+(function(ChangeAnnotation2) {
+  function create(label, needsConfirmation, description) {
+    const result = { label };
+    if (needsConfirmation !== void 0) {
+      result.needsConfirmation = needsConfirmation;
+    }
+    if (description !== void 0) {
+      result.description = description;
+    }
+    return result;
+  }
+  ChangeAnnotation2.create = create;
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
+  }
+  ChangeAnnotation2.is = is;
+})(ChangeAnnotation || (ChangeAnnotation = {}));
+var ChangeAnnotationIdentifier;
+(function(ChangeAnnotationIdentifier2) {
+  function is(value) {
+    const candidate = value;
+    return Is.string(candidate);
+  }
+  ChangeAnnotationIdentifier2.is = is;
+})(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
+var AnnotatedTextEdit;
+(function(AnnotatedTextEdit2) {
+  function replace(range, newText, annotation) {
+    return { range, newText, annotationId: annotation };
+  }
+  AnnotatedTextEdit2.replace = replace;
+  function insert(position, newText, annotation) {
+    return { range: { start: position, end: position }, newText, annotationId: annotation };
+  }
+  AnnotatedTextEdit2.insert = insert;
+  function del(range, annotation) {
+    return { range, newText: "", annotationId: annotation };
+  }
+  AnnotatedTextEdit2.del = del;
+  function is(value) {
+    const candidate = value;
+    return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
+  }
+  AnnotatedTextEdit2.is = is;
+})(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
+var TextDocumentEdit;
+(function(TextDocumentEdit2) {
+  function create(textDocument, edits) {
+    return { textDocument, edits };
+  }
+  TextDocumentEdit2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
+  }
+  TextDocumentEdit2.is = is;
+})(TextDocumentEdit || (TextDocumentEdit = {}));
+var CreateFile;
+(function(CreateFile2) {
+  function create(uri, options, annotation) {
+    let result = {
+      kind: "create",
+      uri
+    };
+    if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
+      result.options = options;
+    }
+    if (annotation !== void 0) {
+      result.annotationId = annotation;
+    }
+    return result;
+  }
+  CreateFile2.create = create;
+  function is(value) {
+    let candidate = value;
+    return candidate && candidate.kind === "create" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
+  }
+  CreateFile2.is = is;
+})(CreateFile || (CreateFile = {}));
+var RenameFile;
+(function(RenameFile2) {
+  function create(oldUri, newUri, options, annotation) {
+    let result = {
+      kind: "rename",
+      oldUri,
+      newUri
+    };
+    if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
+      result.options = options;
+    }
+    if (annotation !== void 0) {
+      result.annotationId = annotation;
+    }
+    return result;
+  }
+  RenameFile2.create = create;
+  function is(value) {
+    let candidate = value;
+    return candidate && candidate.kind === "rename" && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
+  }
+  RenameFile2.is = is;
+})(RenameFile || (RenameFile = {}));
+var DeleteFile;
+(function(DeleteFile2) {
+  function create(uri, options, annotation) {
+    let result = {
+      kind: "delete",
+      uri
+    };
+    if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {
+      result.options = options;
+    }
+    if (annotation !== void 0) {
+      result.annotationId = annotation;
+    }
+    return result;
+  }
+  DeleteFile2.create = create;
+  function is(value) {
+    let candidate = value;
+    return candidate && candidate.kind === "delete" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
+  }
+  DeleteFile2.is = is;
+})(DeleteFile || (DeleteFile = {}));
+var WorkspaceEdit;
+(function(WorkspaceEdit2) {
+  function is(value) {
+    let candidate = value;
+    return candidate && (candidate.changes !== void 0 || candidate.documentChanges !== void 0) && (candidate.documentChanges === void 0 || candidate.documentChanges.every((change) => {
+      if (Is.string(change.kind)) {
+        return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);
+      } else {
+        return TextDocumentEdit.is(change);
+      }
+    }));
+  }
+  WorkspaceEdit2.is = is;
+})(WorkspaceEdit || (WorkspaceEdit = {}));
+var TextDocumentIdentifier;
+(function(TextDocumentIdentifier2) {
+  function create(uri) {
+    return { uri };
+  }
+  TextDocumentIdentifier2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && Is.string(candidate.uri);
+  }
+  TextDocumentIdentifier2.is = is;
+})(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
+var VersionedTextDocumentIdentifier;
+(function(VersionedTextDocumentIdentifier2) {
+  function create(uri, version) {
+    return { uri, version };
+  }
+  VersionedTextDocumentIdentifier2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
+  }
+  VersionedTextDocumentIdentifier2.is = is;
+})(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
+var OptionalVersionedTextDocumentIdentifier;
+(function(OptionalVersionedTextDocumentIdentifier2) {
+  function create(uri, version) {
+    return { uri, version };
+  }
+  OptionalVersionedTextDocumentIdentifier2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
+  }
+  OptionalVersionedTextDocumentIdentifier2.is = is;
+})(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
+var TextDocumentItem;
+(function(TextDocumentItem2) {
+  function create(uri, languageId, version, text) {
+    return { uri, languageId, version, text };
+  }
+  TextDocumentItem2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
+  }
+  TextDocumentItem2.is = is;
+})(TextDocumentItem || (TextDocumentItem = {}));
+var MarkupKind;
+(function(MarkupKind2) {
+  MarkupKind2.PlainText = "plaintext";
+  MarkupKind2.Markdown = "markdown";
+  function is(value) {
+    const candidate = value;
+    return candidate === MarkupKind2.PlainText || candidate === MarkupKind2.Markdown;
+  }
+  MarkupKind2.is = is;
+})(MarkupKind || (MarkupKind = {}));
+var MarkupContent;
+(function(MarkupContent2) {
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
+  }
+  MarkupContent2.is = is;
+})(MarkupContent || (MarkupContent = {}));
+var CompletionItemKind;
+(function(CompletionItemKind2) {
+  CompletionItemKind2.Text = 1;
+  CompletionItemKind2.Method = 2;
+  CompletionItemKind2.Function = 3;
+  CompletionItemKind2.Constructor = 4;
+  CompletionItemKind2.Field = 5;
+  CompletionItemKind2.Variable = 6;
+  CompletionItemKind2.Class = 7;
+  CompletionItemKind2.Interface = 8;
+  CompletionItemKind2.Module = 9;
+  CompletionItemKind2.Property = 10;
+  CompletionItemKind2.Unit = 11;
+  CompletionItemKind2.Value = 12;
+  CompletionItemKind2.Enum = 13;
+  CompletionItemKind2.Keyword = 14;
+  CompletionItemKind2.Snippet = 15;
+  CompletionItemKind2.Color = 16;
+  CompletionItemKind2.File = 17;
+  CompletionItemKind2.Reference = 18;
+  CompletionItemKind2.Folder = 19;
+  CompletionItemKind2.EnumMember = 20;
+  CompletionItemKind2.Constant = 21;
+  CompletionItemKind2.Struct = 22;
+  CompletionItemKind2.Event = 23;
+  CompletionItemKind2.Operator = 24;
+  CompletionItemKind2.TypeParameter = 25;
+})(CompletionItemKind || (CompletionItemKind = {}));
+var InsertTextFormat;
+(function(InsertTextFormat2) {
+  InsertTextFormat2.PlainText = 1;
+  InsertTextFormat2.Snippet = 2;
+})(InsertTextFormat || (InsertTextFormat = {}));
+var CompletionItemTag;
+(function(CompletionItemTag2) {
+  CompletionItemTag2.Deprecated = 1;
+})(CompletionItemTag || (CompletionItemTag = {}));
+var InsertReplaceEdit;
+(function(InsertReplaceEdit2) {
+  function create(newText, insert, replace) {
+    return { newText, insert, replace };
+  }
+  InsertReplaceEdit2.create = create;
+  function is(value) {
+    const candidate = value;
+    return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);
+  }
+  InsertReplaceEdit2.is = is;
+})(InsertReplaceEdit || (InsertReplaceEdit = {}));
+var InsertTextMode;
+(function(InsertTextMode2) {
+  InsertTextMode2.asIs = 1;
+  InsertTextMode2.adjustIndentation = 2;
+})(InsertTextMode || (InsertTextMode = {}));
+var CompletionItemLabelDetails;
+(function(CompletionItemLabelDetails2) {
+  function is(value) {
+    const candidate = value;
+    return candidate && (Is.string(candidate.detail) || candidate.detail === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
+  }
+  CompletionItemLabelDetails2.is = is;
+})(CompletionItemLabelDetails || (CompletionItemLabelDetails = {}));
+var CompletionItem;
+(function(CompletionItem2) {
+  function create(label) {
+    return { label };
+  }
+  CompletionItem2.create = create;
+})(CompletionItem || (CompletionItem = {}));
+var CompletionList;
+(function(CompletionList2) {
+  function create(items, isIncomplete) {
+    return { items: items ? items : [], isIncomplete: !!isIncomplete };
+  }
+  CompletionList2.create = create;
+})(CompletionList || (CompletionList = {}));
+var MarkedString;
+(function(MarkedString2) {
+  function fromPlainText(plainText) {
+    return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
+  }
+  MarkedString2.fromPlainText = fromPlainText;
+  function is(value) {
+    const candidate = value;
+    return Is.string(candidate) || Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value);
+  }
+  MarkedString2.is = is;
+})(MarkedString || (MarkedString = {}));
+var Hover;
+(function(Hover2) {
+  function is(value) {
+    let candidate = value;
+    return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range.is(value.range));
+  }
+  Hover2.is = is;
+})(Hover || (Hover = {}));
+var ParameterInformation;
+(function(ParameterInformation2) {
+  function create(label, documentation) {
+    return documentation ? { label, documentation } : { label };
+  }
+  ParameterInformation2.create = create;
+})(ParameterInformation || (ParameterInformation = {}));
+var SignatureInformation;
+(function(SignatureInformation2) {
+  function create(label, documentation, ...parameters) {
+    let result = { label };
+    if (Is.defined(documentation)) {
+      result.documentation = documentation;
+    }
+    if (Is.defined(parameters)) {
+      result.parameters = parameters;
+    } else {
+      result.parameters = [];
+    }
+    return result;
+  }
+  SignatureInformation2.create = create;
+})(SignatureInformation || (SignatureInformation = {}));
+var DocumentHighlightKind;
+(function(DocumentHighlightKind2) {
+  DocumentHighlightKind2.Text = 1;
+  DocumentHighlightKind2.Read = 2;
+  DocumentHighlightKind2.Write = 3;
+})(DocumentHighlightKind || (DocumentHighlightKind = {}));
+var DocumentHighlight;
+(function(DocumentHighlight2) {
+  function create(range, kind) {
+    let result = { range };
+    if (Is.number(kind)) {
+      result.kind = kind;
+    }
+    return result;
+  }
+  DocumentHighlight2.create = create;
+})(DocumentHighlight || (DocumentHighlight = {}));
+var SymbolKind;
+(function(SymbolKind2) {
+  SymbolKind2.File = 1;
+  SymbolKind2.Module = 2;
+  SymbolKind2.Namespace = 3;
+  SymbolKind2.Package = 4;
+  SymbolKind2.Class = 5;
+  SymbolKind2.Method = 6;
+  SymbolKind2.Property = 7;
+  SymbolKind2.Field = 8;
+  SymbolKind2.Constructor = 9;
+  SymbolKind2.Enum = 10;
+  SymbolKind2.Interface = 11;
+  SymbolKind2.Function = 12;
+  SymbolKind2.Variable = 13;
+  SymbolKind2.Constant = 14;
+  SymbolKind2.String = 15;
+  SymbolKind2.Number = 16;
+  SymbolKind2.Boolean = 17;
+  SymbolKind2.Array = 18;
+  SymbolKind2.Object = 19;
+  SymbolKind2.Key = 20;
+  SymbolKind2.Null = 21;
+  SymbolKind2.EnumMember = 22;
+  SymbolKind2.Struct = 23;
+  SymbolKind2.Event = 24;
+  SymbolKind2.Operator = 25;
+  SymbolKind2.TypeParameter = 26;
+})(SymbolKind || (SymbolKind = {}));
+var SymbolTag;
+(function(SymbolTag2) {
+  SymbolTag2.Deprecated = 1;
+})(SymbolTag || (SymbolTag = {}));
+var SymbolInformation;
+(function(SymbolInformation2) {
+  function create(name, kind, range, uri, containerName) {
+    let result = {
+      name,
+      kind,
+      location: { uri, range }
+    };
+    if (containerName) {
+      result.containerName = containerName;
+    }
+    return result;
+  }
+  SymbolInformation2.create = create;
+})(SymbolInformation || (SymbolInformation = {}));
+var WorkspaceSymbol;
+(function(WorkspaceSymbol2) {
+  function create(name, kind, uri, range) {
+    return range !== void 0 ? { name, kind, location: { uri, range } } : { name, kind, location: { uri } };
+  }
+  WorkspaceSymbol2.create = create;
+})(WorkspaceSymbol || (WorkspaceSymbol = {}));
+var DocumentSymbol;
+(function(DocumentSymbol2) {
+  function create(name, detail, kind, range, selectionRange, children) {
+    let result = {
+      name,
+      detail,
+      kind,
+      range,
+      selectionRange
+    };
+    if (children !== void 0) {
+      result.children = children;
+    }
+    return result;
+  }
+  DocumentSymbol2.create = create;
+  function is(value) {
+    let candidate = value;
+    return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range.is(candidate.range) && Range.is(candidate.selectionRange) && (candidate.detail === void 0 || Is.string(candidate.detail)) && (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) && (candidate.children === void 0 || Array.isArray(candidate.children)) && (candidate.tags === void 0 || Array.isArray(candidate.tags));
+  }
+  DocumentSymbol2.is = is;
+})(DocumentSymbol || (DocumentSymbol = {}));
+var CodeActionKind;
+(function(CodeActionKind2) {
+  CodeActionKind2.Empty = "";
+  CodeActionKind2.QuickFix = "quickfix";
+  CodeActionKind2.Refactor = "refactor";
+  CodeActionKind2.RefactorExtract = "refactor.extract";
+  CodeActionKind2.RefactorInline = "refactor.inline";
+  CodeActionKind2.RefactorRewrite = "refactor.rewrite";
+  CodeActionKind2.Source = "source";
+  CodeActionKind2.SourceOrganizeImports = "source.organizeImports";
+  CodeActionKind2.SourceFixAll = "source.fixAll";
+})(CodeActionKind || (CodeActionKind = {}));
+var CodeActionTriggerKind;
+(function(CodeActionTriggerKind2) {
+  CodeActionTriggerKind2.Invoked = 1;
+  CodeActionTriggerKind2.Automatic = 2;
+})(CodeActionTriggerKind || (CodeActionTriggerKind = {}));
+var CodeActionContext;
+(function(CodeActionContext2) {
+  function create(diagnostics, only, triggerKind) {
+    let result = { diagnostics };
+    if (only !== void 0 && only !== null) {
+      result.only = only;
+    }
+    if (triggerKind !== void 0 && triggerKind !== null) {
+      result.triggerKind = triggerKind;
+    }
+    return result;
+  }
+  CodeActionContext2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string)) && (candidate.triggerKind === void 0 || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);
+  }
+  CodeActionContext2.is = is;
+})(CodeActionContext || (CodeActionContext = {}));
+var CodeAction;
+(function(CodeAction2) {
+  function create(title, kindOrCommandOrEdit, kind) {
+    let result = { title };
+    let checkKind = true;
+    if (typeof kindOrCommandOrEdit === "string") {
+      checkKind = false;
+      result.kind = kindOrCommandOrEdit;
+    } else if (Command.is(kindOrCommandOrEdit)) {
+      result.command = kindOrCommandOrEdit;
+    } else {
+      result.edit = kindOrCommandOrEdit;
+    }
+    if (checkKind && kind !== void 0) {
+      result.kind = kind;
+    }
+    return result;
+  }
+  CodeAction2.create = create;
+  function is(value) {
+    let candidate = value;
+    return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit));
+  }
+  CodeAction2.is = is;
+})(CodeAction || (CodeAction = {}));
+var CodeLens;
+(function(CodeLens2) {
+  function create(range, data) {
+    let result = { range };
+    if (Is.defined(data)) {
+      result.data = data;
+    }
+    return result;
+  }
+  CodeLens2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
+  }
+  CodeLens2.is = is;
+})(CodeLens || (CodeLens = {}));
+var FormattingOptions;
+(function(FormattingOptions2) {
+  function create(tabSize, insertSpaces) {
+    return { tabSize, insertSpaces };
+  }
+  FormattingOptions2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
+  }
+  FormattingOptions2.is = is;
+})(FormattingOptions || (FormattingOptions = {}));
+var DocumentLink;
+(function(DocumentLink2) {
+  function create(range, target, data) {
+    return { range, target, data };
+  }
+  DocumentLink2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
+  }
+  DocumentLink2.is = is;
+})(DocumentLink || (DocumentLink = {}));
+var SelectionRange;
+(function(SelectionRange2) {
+  function create(range, parent) {
+    return { range, parent };
+  }
+  SelectionRange2.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.objectLiteral(candidate) && Range.is(candidate.range) && (candidate.parent === void 0 || SelectionRange2.is(candidate.parent));
+  }
+  SelectionRange2.is = is;
+})(SelectionRange || (SelectionRange = {}));
+var SemanticTokenTypes;
+(function(SemanticTokenTypes2) {
+  SemanticTokenTypes2["namespace"] = "namespace";
+  SemanticTokenTypes2["type"] = "type";
+  SemanticTokenTypes2["class"] = "class";
+  SemanticTokenTypes2["enum"] = "enum";
+  SemanticTokenTypes2["interface"] = "interface";
+  SemanticTokenTypes2["struct"] = "struct";
+  SemanticTokenTypes2["typeParameter"] = "typeParameter";
+  SemanticTokenTypes2["parameter"] = "parameter";
+  SemanticTokenTypes2["variable"] = "variable";
+  SemanticTokenTypes2["property"] = "property";
+  SemanticTokenTypes2["enumMember"] = "enumMember";
+  SemanticTokenTypes2["event"] = "event";
+  SemanticTokenTypes2["function"] = "function";
+  SemanticTokenTypes2["method"] = "method";
+  SemanticTokenTypes2["macro"] = "macro";
+  SemanticTokenTypes2["keyword"] = "keyword";
+  SemanticTokenTypes2["modifier"] = "modifier";
+  SemanticTokenTypes2["comment"] = "comment";
+  SemanticTokenTypes2["string"] = "string";
+  SemanticTokenTypes2["number"] = "number";
+  SemanticTokenTypes2["regexp"] = "regexp";
+  SemanticTokenTypes2["operator"] = "operator";
+  SemanticTokenTypes2["decorator"] = "decorator";
+})(SemanticTokenTypes || (SemanticTokenTypes = {}));
+var SemanticTokenModifiers;
+(function(SemanticTokenModifiers2) {
+  SemanticTokenModifiers2["declaration"] = "declaration";
+  SemanticTokenModifiers2["definition"] = "definition";
+  SemanticTokenModifiers2["readonly"] = "readonly";
+  SemanticTokenModifiers2["static"] = "static";
+  SemanticTokenModifiers2["deprecated"] = "deprecated";
+  SemanticTokenModifiers2["abstract"] = "abstract";
+  SemanticTokenModifiers2["async"] = "async";
+  SemanticTokenModifiers2["modification"] = "modification";
+  SemanticTokenModifiers2["documentation"] = "documentation";
+  SemanticTokenModifiers2["defaultLibrary"] = "defaultLibrary";
+})(SemanticTokenModifiers || (SemanticTokenModifiers = {}));
+var SemanticTokens;
+(function(SemanticTokens2) {
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(candidate) && (candidate.resultId === void 0 || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
+  }
+  SemanticTokens2.is = is;
+})(SemanticTokens || (SemanticTokens = {}));
+var InlineValueText;
+(function(InlineValueText2) {
+  function create(range, text) {
+    return { range, text };
+  }
+  InlineValueText2.create = create;
+  function is(value) {
+    const candidate = value;
+    return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && Is.string(candidate.text);
+  }
+  InlineValueText2.is = is;
+})(InlineValueText || (InlineValueText = {}));
+var InlineValueVariableLookup;
+(function(InlineValueVariableLookup2) {
+  function create(range, variableName, caseSensitiveLookup) {
+    return { range, variableName, caseSensitiveLookup };
+  }
+  InlineValueVariableLookup2.create = create;
+  function is(value) {
+    const candidate = value;
+    return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup) && (Is.string(candidate.variableName) || candidate.variableName === void 0);
+  }
+  InlineValueVariableLookup2.is = is;
+})(InlineValueVariableLookup || (InlineValueVariableLookup = {}));
+var InlineValueEvaluatableExpression;
+(function(InlineValueEvaluatableExpression2) {
+  function create(range, expression) {
+    return { range, expression };
+  }
+  InlineValueEvaluatableExpression2.create = create;
+  function is(value) {
+    const candidate = value;
+    return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && (Is.string(candidate.expression) || candidate.expression === void 0);
+  }
+  InlineValueEvaluatableExpression2.is = is;
+})(InlineValueEvaluatableExpression || (InlineValueEvaluatableExpression = {}));
+var InlineValueContext;
+(function(InlineValueContext2) {
+  function create(frameId, stoppedLocation) {
+    return { frameId, stoppedLocation };
+  }
+  InlineValueContext2.create = create;
+  function is(value) {
+    const candidate = value;
+    return Is.defined(candidate) && Range.is(value.stoppedLocation);
+  }
+  InlineValueContext2.is = is;
+})(InlineValueContext || (InlineValueContext = {}));
+var InlayHintKind;
+(function(InlayHintKind2) {
+  InlayHintKind2.Type = 1;
+  InlayHintKind2.Parameter = 2;
+  function is(value) {
+    return value === 1 || value === 2;
+  }
+  InlayHintKind2.is = is;
+})(InlayHintKind || (InlayHintKind = {}));
+var InlayHintLabelPart;
+(function(InlayHintLabelPart2) {
+  function create(value) {
+    return { value };
+  }
+  InlayHintLabelPart2.create = create;
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(candidate) && (candidate.tooltip === void 0 || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.location === void 0 || Location.is(candidate.location)) && (candidate.command === void 0 || Command.is(candidate.command));
+  }
+  InlayHintLabelPart2.is = is;
+})(InlayHintLabelPart || (InlayHintLabelPart = {}));
+var InlayHint;
+(function(InlayHint2) {
+  function create(position, label, kind) {
+    const result = { position, label };
+    if (kind !== void 0) {
+      result.kind = kind;
+    }
+    return result;
+  }
+  InlayHint2.create = create;
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(candidate) && Position.is(candidate.position) && (Is.string(candidate.label) || Is.typedArray(candidate.label, InlayHintLabelPart.is)) && (candidate.kind === void 0 || InlayHintKind.is(candidate.kind)) && candidate.textEdits === void 0 || Is.typedArray(candidate.textEdits, TextEdit.is) && (candidate.tooltip === void 0 || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.paddingLeft === void 0 || Is.boolean(candidate.paddingLeft)) && (candidate.paddingRight === void 0 || Is.boolean(candidate.paddingRight));
+  }
+  InlayHint2.is = is;
+})(InlayHint || (InlayHint = {}));
+var StringValue;
+(function(StringValue2) {
+  function createSnippet(value) {
+    return { kind: "snippet", value };
+  }
+  StringValue2.createSnippet = createSnippet;
+})(StringValue || (StringValue = {}));
+var InlineCompletionItem;
+(function(InlineCompletionItem2) {
+  function create(insertText, filterText, range, command) {
+    return { insertText, filterText, range, command };
+  }
+  InlineCompletionItem2.create = create;
+})(InlineCompletionItem || (InlineCompletionItem = {}));
+var InlineCompletionList;
+(function(InlineCompletionList2) {
+  function create(items) {
+    return { items };
+  }
+  InlineCompletionList2.create = create;
+})(InlineCompletionList || (InlineCompletionList = {}));
+var InlineCompletionTriggerKind;
+(function(InlineCompletionTriggerKind2) {
+  InlineCompletionTriggerKind2.Invoked = 0;
+  InlineCompletionTriggerKind2.Automatic = 1;
+})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));
+var SelectedCompletionInfo;
+(function(SelectedCompletionInfo2) {
+  function create(range, text) {
+    return { range, text };
+  }
+  SelectedCompletionInfo2.create = create;
+})(SelectedCompletionInfo || (SelectedCompletionInfo = {}));
+var InlineCompletionContext;
+(function(InlineCompletionContext2) {
+  function create(triggerKind, selectedCompletionInfo) {
+    return { triggerKind, selectedCompletionInfo };
+  }
+  InlineCompletionContext2.create = create;
+})(InlineCompletionContext || (InlineCompletionContext = {}));
+var WorkspaceFolder;
+(function(WorkspaceFolder2) {
+  function is(value) {
+    const candidate = value;
+    return Is.objectLiteral(candidate) && URI.is(candidate.uri) && Is.string(candidate.name);
+  }
+  WorkspaceFolder2.is = is;
+})(WorkspaceFolder || (WorkspaceFolder = {}));
+var TextDocument;
+(function(TextDocument3) {
+  function create(uri, languageId, version, content) {
+    return new FullTextDocument(uri, languageId, version, content);
+  }
+  TextDocument3.create = create;
+  function is(value) {
+    let candidate = value;
+    return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
+  }
+  TextDocument3.is = is;
+  function applyEdits(document2, edits) {
+    let text = document2.getText();
+    let sortedEdits = mergeSort2(edits, (a, b) => {
+      let diff = a.range.start.line - b.range.start.line;
+      if (diff === 0) {
+        return a.range.start.character - b.range.start.character;
+      }
+      return diff;
+    });
+    let lastModifiedOffset = text.length;
+    for (let i = sortedEdits.length - 1; i >= 0; i--) {
+      let e = sortedEdits[i];
+      let startOffset = document2.offsetAt(e.range.start);
+      let endOffset = document2.offsetAt(e.range.end);
+      if (endOffset <= lastModifiedOffset) {
+        text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);
+      } else {
+        throw new Error("Overlapping edit");
+      }
+      lastModifiedOffset = startOffset;
+    }
+    return text;
+  }
+  TextDocument3.applyEdits = applyEdits;
+  function mergeSort2(data, compare) {
+    if (data.length <= 1) {
+      return data;
+    }
+    const p = data.length / 2 | 0;
+    const left = data.slice(0, p);
+    const right = data.slice(p);
+    mergeSort2(left, compare);
+    mergeSort2(right, compare);
+    let leftIdx = 0;
+    let rightIdx = 0;
+    let i = 0;
+    while (leftIdx < left.length && rightIdx < right.length) {
+      let ret = compare(left[leftIdx], right[rightIdx]);
+      if (ret <= 0) {
+        data[i++] = left[leftIdx++];
+      } else {
+        data[i++] = right[rightIdx++];
+      }
+    }
+    while (leftIdx < left.length) {
+      data[i++] = left[leftIdx++];
+    }
+    while (rightIdx < right.length) {
+      data[i++] = right[rightIdx++];
+    }
+    return data;
+  }
+})(TextDocument || (TextDocument = {}));
+var FullTextDocument = class {
+  constructor(uri, languageId, version, content) {
+    this._uri = uri;
+    this._languageId = languageId;
+    this._version = version;
+    this._content = content;
+    this._lineOffsets = void 0;
+  }
+  get uri() {
+    return this._uri;
+  }
+  get languageId() {
+    return this._languageId;
+  }
+  get version() {
+    return this._version;
+  }
+  getText(range) {
+    if (range) {
+      let start = this.offsetAt(range.start);
+      let end = this.offsetAt(range.end);
+      return this._content.substring(start, end);
+    }
+    return this._content;
+  }
+  update(event, version) {
+    this._content = event.text;
+    this._version = version;
+    this._lineOffsets = void 0;
+  }
+  getLineOffsets() {
+    if (this._lineOffsets === void 0) {
+      let lineOffsets = [];
+      let text = this._content;
+      let isLineStart = true;
+      for (let i = 0; i < text.length; i++) {
+        if (isLineStart) {
+          lineOffsets.push(i);
+          isLineStart = false;
+        }
+        let ch = text.charAt(i);
+        isLineStart = ch === "\r" || ch === "\n";
+        if (ch === "\r" && i + 1 < text.length && text.charAt(i + 1) === "\n") {
+          i++;
+        }
+      }
+      if (isLineStart && text.length > 0) {
+        lineOffsets.push(text.length);
+      }
+      this._lineOffsets = lineOffsets;
+    }
+    return this._lineOffsets;
+  }
+  positionAt(offset) {
+    offset = Math.max(Math.min(offset, this._content.length), 0);
+    let lineOffsets = this.getLineOffsets();
+    let low = 0, high = lineOffsets.length;
+    if (high === 0) {
+      return Position.create(0, offset);
+    }
+    while (low < high) {
+      let mid = Math.floor((low + high) / 2);
+      if (lineOffsets[mid] > offset) {
+        high = mid;
+      } else {
+        low = mid + 1;
+      }
+    }
+    let line = low - 1;
+    return Position.create(line, offset - lineOffsets[line]);
+  }
+  offsetAt(position) {
+    let lineOffsets = this.getLineOffsets();
+    if (position.line >= lineOffsets.length) {
+      return this._content.length;
+    } else if (position.line < 0) {
+      return 0;
+    }
+    let lineOffset = lineOffsets[position.line];
+    let nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
+    return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
+  }
+  get lineCount() {
+    return this.getLineOffsets().length;
+  }
+};
+var Is;
+(function(Is2) {
+  const toString = Object.prototype.toString;
+  function defined(value) {
+    return typeof value !== "undefined";
+  }
+  Is2.defined = defined;
+  function undefined2(value) {
+    return typeof value === "undefined";
+  }
+  Is2.undefined = undefined2;
+  function boolean(value) {
+    return value === true || value === false;
+  }
+  Is2.boolean = boolean;
+  function string(value) {
+    return toString.call(value) === "[object String]";
+  }
+  Is2.string = string;
+  function number(value) {
+    return toString.call(value) === "[object Number]";
+  }
+  Is2.number = number;
+  function numberRange(value, min, max) {
+    return toString.call(value) === "[object Number]" && min <= value && value <= max;
+  }
+  Is2.numberRange = numberRange;
+  function integer2(value) {
+    return toString.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
+  }
+  Is2.integer = integer2;
+  function uinteger2(value) {
+    return toString.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
+  }
+  Is2.uinteger = uinteger2;
+  function func(value) {
+    return toString.call(value) === "[object Function]";
+  }
+  Is2.func = func;
+  function objectLiteral(value) {
+    return value !== null && typeof value === "object";
+  }
+  Is2.objectLiteral = objectLiteral;
+  function typedArray(value, check) {
+    return Array.isArray(value) && value.every(check);
+  }
+  Is2.typedArray = typedArray;
+})(Is || (Is = {}));
+
+// node_modules/.pnpm/vscode-languageserver-textdocument@1.0.12/node_modules/vscode-languageserver-textdocument/lib/esm/main.js
+var FullTextDocument2 = class _FullTextDocument {
+  constructor(uri, languageId, version, content) {
+    this._uri = uri;
+    this._languageId = languageId;
+    this._version = version;
+    this._content = content;
+    this._lineOffsets = void 0;
+  }
+  get uri() {
+    return this._uri;
+  }
+  get languageId() {
+    return this._languageId;
+  }
+  get version() {
+    return this._version;
+  }
+  getText(range) {
+    if (range) {
+      const start = this.offsetAt(range.start);
+      const end = this.offsetAt(range.end);
+      return this._content.substring(start, end);
+    }
+    return this._content;
+  }
+  update(changes, version) {
+    for (const change of changes) {
+      if (_FullTextDocument.isIncremental(change)) {
+        const range = getWellformedRange(change.range);
+        const startOffset = this.offsetAt(range.start);
+        const endOffset = this.offsetAt(range.end);
+        this._content = this._content.substring(0, startOffset) + change.text + this._content.substring(endOffset, this._content.length);
+        const startLine = Math.max(range.start.line, 0);
+        const endLine = Math.max(range.end.line, 0);
+        let lineOffsets = this._lineOffsets;
+        const addedLineOffsets = computeLineOffsets(change.text, false, startOffset);
+        if (endLine - startLine === addedLineOffsets.length) {
+          for (let i = 0, len = addedLineOffsets.length; i < len; i++) {
+            lineOffsets[i + startLine + 1] = addedLineOffsets[i];
+          }
+        } else {
+          if (addedLineOffsets.length < 1e4) {
+            lineOffsets.splice(startLine + 1, endLine - startLine, ...addedLineOffsets);
+          } else {
+            this._lineOffsets = lineOffsets = lineOffsets.slice(0, startLine + 1).concat(addedLineOffsets, lineOffsets.slice(endLine + 1));
+          }
+        }
+        const diff = change.text.length - (endOffset - startOffset);
+        if (diff !== 0) {
+          for (let i = startLine + 1 + addedLineOffsets.length, len = lineOffsets.length; i < len; i++) {
+            lineOffsets[i] = lineOffsets[i] + diff;
+          }
+        }
+      } else if (_FullTextDocument.isFull(change)) {
+        this._content = change.text;
+        this._lineOffsets = void 0;
+      } else {
+        throw new Error("Unknown change event received");
+      }
+    }
+    this._version = version;
+  }
+  getLineOffsets() {
+    if (this._lineOffsets === void 0) {
+      this._lineOffsets = computeLineOffsets(this._content, true);
+    }
+    return this._lineOffsets;
+  }
+  positionAt(offset) {
+    offset = Math.max(Math.min(offset, this._content.length), 0);
+    const lineOffsets = this.getLineOffsets();
+    let low = 0, high = lineOffsets.length;
+    if (high === 0) {
+      return { line: 0, character: offset };
+    }
+    while (low < high) {
+      const mid = Math.floor((low + high) / 2);
+      if (lineOffsets[mid] > offset) {
+        high = mid;
+      } else {
+        low = mid + 1;
+      }
+    }
+    const line = low - 1;
+    offset = this.ensureBeforeEOL(offset, lineOffsets[line]);
+    return { line, character: offset - lineOffsets[line] };
+  }
+  offsetAt(position) {
+    const lineOffsets = this.getLineOffsets();
+    if (position.line >= lineOffsets.length) {
+      return this._content.length;
+    } else if (position.line < 0) {
+      return 0;
+    }
+    const lineOffset = lineOffsets[position.line];
+    if (position.character <= 0) {
+      return lineOffset;
+    }
+    const nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
+    const offset = Math.min(lineOffset + position.character, nextLineOffset);
+    return this.ensureBeforeEOL(offset, lineOffset);
+  }
+  ensureBeforeEOL(offset, lineOffset) {
+    while (offset > lineOffset && isEOL(this._content.charCodeAt(offset - 1))) {
+      offset--;
+    }
+    return offset;
+  }
+  get lineCount() {
+    return this.getLineOffsets().length;
+  }
+  static isIncremental(event) {
+    const candidate = event;
+    return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range !== void 0 && (candidate.rangeLength === void 0 || typeof candidate.rangeLength === "number");
+  }
+  static isFull(event) {
+    const candidate = event;
+    return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range === void 0 && candidate.rangeLength === void 0;
+  }
+};
+var TextDocument2;
+(function(TextDocument3) {
+  function create(uri, languageId, version, content) {
+    return new FullTextDocument2(uri, languageId, version, content);
+  }
+  TextDocument3.create = create;
+  function update(document2, changes, version) {
+    if (document2 instanceof FullTextDocument2) {
+      document2.update(changes, version);
+      return document2;
+    } else {
+      throw new Error("TextDocument.update: document must be created by TextDocument.create");
+    }
+  }
+  TextDocument3.update = update;
+  function applyEdits(document2, edits) {
+    const text = document2.getText();
+    const sortedEdits = mergeSort(edits.map(getWellformedEdit), (a, b) => {
+      const diff = a.range.start.line - b.range.start.line;
+      if (diff === 0) {
+        return a.range.start.character - b.range.start.character;
+      }
+      return diff;
+    });
+    let lastModifiedOffset = 0;
+    const spans = [];
+    for (const e of sortedEdits) {
+      const startOffset = document2.offsetAt(e.range.start);
+      if (startOffset < lastModifiedOffset) {
+        throw new Error("Overlapping edit");
+      } else if (startOffset > lastModifiedOffset) {
+        spans.push(text.substring(lastModifiedOffset, startOffset));
+      }
+      if (e.newText.length) {
+        spans.push(e.newText);
+      }
+      lastModifiedOffset = document2.offsetAt(e.range.end);
+    }
+    spans.push(text.substr(lastModifiedOffset));
+    return spans.join("");
+  }
+  TextDocument3.applyEdits = applyEdits;
+})(TextDocument2 || (TextDocument2 = {}));
+function mergeSort(data, compare) {
+  if (data.length <= 1) {
+    return data;
+  }
+  const p = data.length / 2 | 0;
+  const left = data.slice(0, p);
+  const right = data.slice(p);
+  mergeSort(left, compare);
+  mergeSort(right, compare);
+  let leftIdx = 0;
+  let rightIdx = 0;
+  let i = 0;
+  while (leftIdx < left.length && rightIdx < right.length) {
+    const ret = compare(left[leftIdx], right[rightIdx]);
+    if (ret <= 0) {
+      data[i++] = left[leftIdx++];
+    } else {
+      data[i++] = right[rightIdx++];
+    }
+  }
+  while (leftIdx < left.length) {
+    data[i++] = left[leftIdx++];
+  }
+  while (rightIdx < right.length) {
+    data[i++] = right[rightIdx++];
+  }
+  return data;
+}
+function computeLineOffsets(text, isAtLineStart, textOffset = 0) {
+  const result = isAtLineStart ? [textOffset] : [];
+  for (let i = 0; i < text.length; i++) {
+    const ch = text.charCodeAt(i);
+    if (isEOL(ch)) {
+      if (ch === 13 && i + 1 < text.length && text.charCodeAt(i + 1) === 10) {
+        i++;
+      }
+      result.push(textOffset + i + 1);
+    }
+  }
+  return result;
+}
+function isEOL(char) {
+  return char === 13 || char === 10;
+}
+function getWellformedRange(range) {
+  const start = range.start;
+  const end = range.end;
+  if (start.line > end.line || start.line === end.line && start.character > end.character) {
+    return { start: end, end: start };
+  }
+  return range;
+}
+function getWellformedEdit(textEdit) {
+  const range = getWellformedRange(textEdit.range);
+  if (range !== textEdit.range) {
+    return { newText: textEdit.newText, range };
+  }
+  return textEdit;
+}
+
+// src/lsp/worker-base.ts
+var WorkerBase = class {
+  constructor(_ctx, _createLanguageDocument) {
+    this._ctx = _ctx;
+    this._createLanguageDocument = _createLanguageDocument;
+  }
+  _documentCache = /* @__PURE__ */ new Map();
+  _fsEntries;
+  get hasFileSystemProvider() {
+    return !!this._fsEntries;
+  }
+  get host() {
+    return this._ctx.host;
+  }
+  getMirrorModels() {
+    return this._ctx.getMirrorModels();
+  }
+  hasModel(fileName) {
+    const models = this.getMirrorModels();
+    for (let i = 0; i < models.length; i++) {
+      const uri = models[i].uri;
+      if (uri.toString() === fileName || uri.toString(true) === fileName) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getModel(fileName) {
+    const models = this.getMirrorModels();
+    for (let i = 0; i < models.length; i++) {
+      const uri = models[i].uri;
+      if (uri.toString() === fileName || uri.toString(true) === fileName) {
+        return models[i];
+      }
+    }
+    return null;
+  }
+  getTextDocument(uri) {
+    const model = this.getModel(uri);
+    if (!model) {
+      return null;
+    }
+    const cached = this._documentCache.get(uri);
+    if (cached && cached[0] === model.version) {
+      return cached[1];
+    }
+    const document2 = TextDocument2.create(uri, "-", model.version, model.getValue());
+    this._documentCache.set(uri, [model.version, document2, void 0]);
+    return document2;
+  }
+  getLanguageDocument(document2) {
+    const { uri, version } = document2;
+    const cached = this._documentCache.get(uri);
+    if (cached && cached[0] === version && cached[2]) {
+      return cached[2];
+    }
+    if (!this._createLanguageDocument) {
+      throw new Error("createLanguageDocument is not provided");
+    }
+    const languageDocument = this._createLanguageDocument(document2);
+    this._documentCache.set(uri, [version, document2, languageDocument]);
+    return languageDocument;
+  }
+  readDir(uri, extensions) {
+    const entries = [];
+    const fsTree = this._fsEntries;
+    if (fsTree) {
+      for (const [path, type] of fsTree) {
+        if (path.startsWith(uri)) {
+          const name = path.slice(uri.length);
+          if (!name.includes("/")) {
+            if (type === 2) {
+              entries.push([name, 2 /* Directory */]);
+            } else if (!extensions || extensions.some((ext) => name.endsWith(ext))) {
+              entries.push([name, 1 /* File */]);
+            }
+          }
+        }
+      }
+    }
+    return entries;
+  }
+  getFileSystemProvider() {
+    if (this.hasFileSystemProvider) {
+      const host = this._ctx.host;
+      return {
+        readDirectory: (uri) => {
+          return Promise.resolve(this.readDir(uri));
+        },
+        stat: (uri) => {
+          return host.fs_stat(uri);
+        },
+        getContent: (uri, encoding) => {
+          return host.fs_getContent(uri);
+        }
+      };
+    }
+    return void 0;
+  }
+  // resolveReference implementes the `DocumentContext` interface
+  resolveReference(ref, baseUrl) {
+    const url = new URL(ref, baseUrl);
+    const href = url.href;
+    if (url.protocol === "file:" && this._fsEntries) {
+      if (!this._fsEntries.has(href)) {
+        return void 0;
+      }
+    }
+    return href;
+  }
+  // #region methods used by the host
+  async removeDocumentCache(uri) {
+    this._documentCache.delete(uri);
+  }
+  async syncFSEntries(entries) {
+    this._fsEntries = new Map(entries);
+  }
+  async fsNotify(kind, path, type) {
+    const url = "file://" + path;
+    const entries = this._fsEntries ?? (this._fsEntries = /* @__PURE__ */ new Map());
+    if (kind === "create") {
+      if (type) {
+        entries.set(url, type);
+      }
+    } else if (kind === "remove") {
+      if (entries.get(url) === 1 /* File */) {
+        this._documentCache.delete(url);
+      }
+      entries.delete(url);
+    }
+  }
+  // #endregion
+};
+
+// src/lsp/typescript/worker.ts
+import libs from "./libs.js";
+import { cache } from "../../cache.js";
+import { initializeWorker } from "../../editor-worker.js";
+var TypeScriptWorker = class extends WorkerBase {
+  _compilerOptions;
+  _importMap;
+  _importMapVersion;
+  _isBlankImportMap;
+  _types;
+  _formatOptions;
+  _languageService = ts.createLanguageService(this);
+  _urlMappings = /* @__PURE__ */ new Map();
+  _typesMappings = /* @__PURE__ */ new Map();
+  _httpLibs = /* @__PURE__ */ new Map();
+  _httpModules = /* @__PURE__ */ new Map();
+  _httpTsModules = /* @__PURE__ */ new Map();
+  _redirectedImports = [];
+  _unknownImports = /* @__PURE__ */ new Set();
+  _badImports = /* @__PURE__ */ new Set();
+  _openPromises = /* @__PURE__ */ new Map();
+  _fetchPromises = /* @__PURE__ */ new Map();
+  _httpDocumentCache = /* @__PURE__ */ new Map();
+  constructor(ctx, createData) {
+    super(ctx);
+    this._compilerOptions = ts.convertCompilerOptionsFromJson(createData.compilerOptions, ".").options;
+    this._importMap = createData.importMap;
+    this._importMapVersion = 0;
+    this._isBlankImportMap = isBlankImportMap(createData.importMap);
+    this._types = createData.types;
+    this._formatOptions = createData.formatOptions;
+    this._updateJsxImportSource();
+  }
+  // #region language service host
+  getCurrentDirectory() {
+    return "/";
+  }
+  getDirectories(path) {
+    if (path === "/node_modules/@types") {
+      return [];
+    }
+    if (path.startsWith("file:///node_modules/")) {
+      const dirname = path.slice("file:///node_modules/".length);
+      return Object.keys(this._importMap.imports).filter((key) => key !== "@jsxRuntime" && (dirname.length === 0 || key.startsWith(dirname))).map((key) => dirname.length > 0 ? key.slice(dirname.length) : key).filter((key) => key !== "/" && key.includes("/")).map((key) => key.split("/")[0]);
+    }
+    return this.readDir(path).filter(([_, type]) => type === 2 /* Directory */).map(([name, _]) => name);
+  }
+  readDirectory(path, extensions, exclude, include, depth) {
+    if (path.startsWith("file:///node_modules/")) {
+      const dirname = path.slice("file:///node_modules/".length);
+      return Object.keys(this._importMap.imports).filter((key) => key !== "@jsxRuntime" && (dirname.length === 0 || key.startsWith(dirname))).map((key) => dirname.length > 0 ? key.slice(dirname.length) : key).filter((key) => !key.includes("/"));
+    }
+    return this.readDir(path, extensions).filter(([_, type]) => type === 1 /* File */).map(([name, _]) => name);
+  }
+  fileExists(filename) {
+    if (filename.startsWith("/node_modules/")) return false;
+    return filename in libs || `lib.${filename}.d.ts` in libs || filename in this._types || this._httpLibs.has(filename) || this._httpModules.has(filename) || this._httpTsModules.has(filename) || this.hasModel(filename);
+  }
+  readFile(filename) {
+    return this._getScriptText(filename);
+  }
+  getScriptFileNames() {
+    const models = this.getMirrorModels();
+    const types = Object.keys(this._types);
+    const libNames = Object.keys(libs);
+    const filenames = new Array(
+      models.length + types.length + libNames.length + this._httpLibs.size + this._httpModules.size + this._httpTsModules.size
+    );
+    let i = 0;
+    for (const model of models) {
+      filenames[i++] = model.uri.toString();
+    }
+    for (const filename of types) {
+      filenames[i++] = filename;
+    }
+    for (const filename of libNames) {
+      filenames[i++] = filename;
+    }
+    for (const filename of this._httpLibs.keys()) {
+      filenames[i++] = filename;
+    }
+    for (const filename of this._httpModules.keys()) {
+      filenames[i++] = filename;
+    }
+    for (const filename of this._httpTsModules.keys()) {
+      filenames[i++] = filename;
+    }
+    return filenames;
+  }
+  getScriptVersion(fileName) {
+    if (fileName in this._types) {
+      return String(this._types[fileName].version);
+    }
+    if (fileName in libs || fileName in this._types || this._httpLibs.has(fileName) || this._httpModules.has(fileName) || this._httpTsModules.has(fileName)) {
+      return "1";
+    }
+    const model = this.getModel(fileName);
+    if (model) {
+      return this._importMapVersion + "." + model.version;
+    }
+    return "0";
+  }
+  getScriptSnapshot(fileName) {
+    const text = this._getScriptText(fileName);
+    if (text === void 0) {
+      return void 0;
+    }
+    return ts.ScriptSnapshot.fromString(text);
+  }
+  getCompilationSettings() {
+    return this._compilerOptions;
+  }
+  getDefaultLibFileName(options) {
+    switch (options.target) {
+      case 0:
+      case 1:
+        return "lib.d.ts";
+      case 2:
+        return "lib.es6.d.ts";
+      case 3:
+      case 4:
+      case 5:
+      case 6:
+      case 7:
+      case 8:
+      case 9:
+      case 10:
+        return `lib.es${2013 + options.target}.full.d.ts`;
+      case 99:
+        return "lib.esnext.full.d.ts";
+      default:
+        return "lib.es6.d.ts";
+    }
+  }
+  resolveModuleNameLiterals(moduleLiterals, containingFile, _redirectedReference, _options, _containingSourceFile, _reusedNames) {
+    this._redirectedImports = this._redirectedImports.filter(([modelUrl]) => modelUrl !== containingFile);
+    return moduleLiterals.map((literal) => {
+      let specifier = literal.text;
+      let importMapResolved = false;
+      if (!this._isBlankImportMap) {
+        const [url, resolved] = resolve(this._importMap, specifier, containingFile);
+        importMapResolved = resolved;
+        if (importMapResolved) {
+          specifier = url;
+        }
+      }
+      if (!importMapResolved && !isHttpUrl(specifier) && !isRelativePath(specifier)) {
+        return void 0;
+      }
+      let moduleUrl;
+      try {
+        moduleUrl = new URL(specifier, pathToUrl(containingFile));
+      } catch (error) {
+        return void 0;
+      }
+      if (getScriptExtension(moduleUrl.pathname) === null) {
+        const ext = getScriptExtension(containingFile);
+        if (ext === ".d.ts" || ext === ".d.mts" || ext === ".d.cts") {
+          moduleUrl.pathname += ext;
+        }
+      }
+      if (this._httpModules.has(containingFile)) {
+        return {
+          resolvedFileName: moduleUrl.href,
+          extension: ".js"
+        };
+      }
+      if (moduleUrl.protocol === "file:") {
+        const moduleHref = moduleUrl.href;
+        if (this._badImports.has(moduleHref)) {
+          return void 0;
+        }
+        for (const model of this.getMirrorModels()) {
+          if (moduleHref === model.uri.toString()) {
+            return {
+              resolvedFileName: moduleHref,
+              extension: getScriptExtension(moduleUrl.pathname) ?? ".js"
+            };
+          }
+        }
+        if (!this.hasFileSystemProvider) {
+          return void 0;
+        }
+        if (!this._openPromises.has(moduleHref)) {
+          this._openPromises.set(
+            moduleHref,
+            this.host.openModel(moduleHref).then((ok) => {
+              if (!ok) {
+                this._badImports.add(moduleHref);
+                this._rollbackVersion(containingFile);
+              }
+            }).finally(() => {
+              this._openPromises.delete(moduleHref);
+              this.host.refreshDiagnostics(containingFile);
+            })
+          );
+        }
+      } else {
+        const moduleHref = moduleUrl.href;
+        if (this._badImports.has(moduleHref) || this._unknownImports.has(moduleHref)) {
+          return void 0;
+        }
+        if (!importMapResolved && this._urlMappings.has(moduleHref)) {
+          const redirectUrl = this._urlMappings.get(moduleHref);
+          this._redirectedImports.push([containingFile, literal, redirectUrl]);
+        }
+        if (this._httpModules.has(moduleHref)) {
+          return {
+            resolvedFileName: moduleHref,
+            extension: getScriptExtension(moduleUrl.pathname) ?? ".js"
+          };
+        }
+        if (this._httpTsModules.has(moduleHref)) {
+          return {
+            resolvedFileName: moduleHref,
+            extension: getScriptExtension(moduleUrl.pathname) ?? ".ts"
+          };
+        }
+        if (this._typesMappings.has(moduleHref)) {
+          return {
+            resolvedFileName: this._typesMappings.get(moduleHref),
+            extension: ".d.ts"
+          };
+        }
+        if (this._httpLibs.has(moduleHref)) {
+          return {
+            resolvedFileName: moduleHref,
+            extension: ".d.ts"
+          };
+        }
+        if (!this._fetchPromises.has(moduleHref)) {
+          const autoFetch = importMapResolved || this._isJsxImportUrl(specifier) || isHttpUrl(containingFile) || isWellKnownCDNURL(moduleUrl);
+          const promise = autoFetch ? cache.fetch(moduleUrl) : cache.query(moduleUrl);
+          this._fetchPromises.set(
+            moduleHref,
+            promise.then(async (res) => {
+              if (!res) {
+                this._unknownImports.add(moduleHref);
+                return;
+              }
+              if (res.ok) {
+                const contentType = res.headers.get("content-type");
+                const dts = res.headers.get("x-typescript-types");
+                if (res.redirected) {
+                  this._urlMappings.set(moduleHref, res.url);
+                } else if (dts) {
+                  res.body?.cancel();
+                  const dtsRes = await cache.fetch(new URL(dts, res.url));
+                  if (dtsRes.ok) {
+                    this._typesMappings.set(moduleHref, dtsRes.url);
+                    this._markHttpLib(dtsRes.url, await dtsRes.text());
+                  }
+                } else if (/\.(c|m)?jsx?$/.test(moduleUrl.pathname) || contentType && /^(application|text)\/(javascript|jsx)/.test(contentType)) {
+                  this._httpModules.set(moduleHref, await res.text());
+                } else if (/\.(c|m)?tsx?$/.test(moduleUrl.pathname) || contentType && /^(application|text)\/(typescript|tsx)/.test(contentType)) {
+                  if (/\.d\.(c|m)?ts$/.test(moduleUrl.pathname)) {
+                    this._markHttpLib(moduleHref, await res.text());
+                  } else {
+                    this._httpTsModules.set(moduleHref, await res.text());
+                  }
+                } else {
+                  res.body?.cancel();
+                  this._badImports.add(moduleHref);
+                }
+              } else {
+                res.body?.cancel();
+                this._badImports.add(moduleHref);
+              }
+            }).catch((err) => {
+              console.error(`Failed to fetch module: ${moduleHref}`, err);
+            }).finally(() => {
+              this._rollbackVersion(containingFile);
+              this._fetchPromises.delete(moduleHref);
+              this.host.refreshDiagnostics(containingFile);
+            })
+          );
+        }
+      }
+      return { resolvedFileName: specifier, extension: ".js" };
+    }).map((resolvedModule) => {
+      return { resolvedModule };
+    });
+  }
+  // #endregion
+  // #region language features
+  async doValidation(uri) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const ext = getScriptExtension(uri);
+    const diagnostics = [];
+    for (const diagnostic of this._languageService.getSyntacticDiagnostics(uri)) {
+      diagnostics.push(this._convertDiagnostic(document2, diagnostic));
+    }
+    for (const diagnostic of this._languageService.getSuggestionDiagnostics(uri)) {
+      diagnostics.push(this._convertDiagnostic(document2, diagnostic));
+    }
+    if (ext === ".tsx" || ext?.endsWith("ts")) {
+      for (const diagnostic of this._languageService.getSemanticDiagnostics(uri)) {
+        diagnostics.push(this._convertDiagnostic(document2, diagnostic));
+      }
+    }
+    if (this._redirectedImports.length > 0) {
+      this._redirectedImports.forEach(([modelUrl, node, url]) => {
+        if (modelUrl === uri) {
+          diagnostics.push(this._convertDiagnostic(document2, {
+            file: void 0,
+            start: node.getStart(),
+            length: node.getWidth(),
+            code: 7e3,
+            category: ts.DiagnosticCategory.Message,
+            messageText: `The module was redirected to ${url}`
+          }));
+        }
+      });
+    }
+    return diagnostics;
+  }
+  async doAutoComplete(uri, position, ch) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const info = this._languageService.getJsxClosingTagAtPosition(uri, document2.offsetAt(position));
+    if (info) {
+      return "$0" + info.newText;
+    }
+    return null;
+  }
+  async doComplete(uri, position) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const offset = document2.offsetAt(position);
+    const completions = this._getCompletionsAtPosition(uri, offset);
+    if (!completions) {
+      return { isIncomplete: false, items: [] };
+    }
+    const items = [];
+    for (const entry of completions.entries) {
+      if (entry.name === "") {
+        continue;
+      }
+      if (entry.kind === "script" && entry.name in this._importMap.imports || entry.name + "/" in this._importMap.imports) {
+        const { replacementSpan } = entry;
+        if (replacementSpan?.length) {
+          const replacementText = document2.getText({
+            start: document2.positionAt(replacementSpan.start),
+            end: document2.positionAt(replacementSpan.start + replacementSpan.length)
+          });
+          if (replacementText.startsWith(".")) {
+            continue;
+          }
+        }
+      }
+      const data = { entryData: entry.data, context: { uri, offset } };
+      const tags = [];
+      if (entry.kindModifiers?.includes("deprecated")) {
+        tags.push(CompletionItemTag.Deprecated);
+      }
+      items.push({
+        label: entry.name,
+        insertText: entry.name,
+        filterText: entry.filterText,
+        sortText: entry.sortText,
+        kind: convertTsCompletionItemKind(entry.kind),
+        tags,
+        data
+      });
+    }
+    return {
+      isIncomplete: !!completions.isIncomplete,
+      items
+    };
+  }
+  async doResolveCompletionItem(item) {
+    if (!item.data?.context) {
+      return null;
+    }
+    const { uri, offset } = item.data.context;
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const details = this._getCompletionEntryDetails(uri, offset, item.label, item.data.entryData);
+    if (!details) {
+      return null;
+    }
+    const detail = ts.displayPartsToString(details.displayParts);
+    const documentation = ts.displayPartsToString(details.documentation);
+    const additionalTextEdits = [];
+    if (details.codeActions) {
+      details.codeActions.forEach(
+        (action) => action.changes.forEach(
+          (change) => change.textChanges.forEach(({ span, newText }) => {
+            additionalTextEdits.push({
+              range: createRangeFromDocumentSpan(document2, span),
+              newText
+            });
+          })
+        )
+      );
+    }
+    return { label: item.label, detail, documentation, additionalTextEdits };
+  }
+  async doHover(uri, position) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const info = this._getQuickInfoAtPosition(uri, document2.offsetAt(position));
+    if (info) {
+      const contents = ts.displayPartsToString(info.displayParts);
+      const documentation = ts.displayPartsToString(info.documentation);
+      const tags = info.tags?.map((tag) => tagStringify(tag)).join("  \n\n") ?? null;
+      return {
+        range: createRangeFromDocumentSpan(document2, info.textSpan),
+        contents: [
+          { language: "typescript", value: contents },
+          documentation + (tags ? "\n\n" + tags : "")
+        ]
+      };
+    }
+    return null;
+  }
+  async doSignatureHelp(uri, position, context) {
+    const triggerReason = toTsSignatureHelpTriggerReason(context);
+    const items = this._languageService.getSignatureHelpItems(uri, position, { triggerReason });
+    if (!items) {
+      return null;
+    }
+    const activeSignature = items.selectedItemIndex;
+    const activeParameter = items.argumentIndex;
+    const signatures = items.items.map((item) => {
+      const signature = { label: "", parameters: [] };
+      signature.documentation = ts.displayPartsToString(item.documentation);
+      signature.label += ts.displayPartsToString(item.prefixDisplayParts);
+      item.parameters.forEach((p, i, a) => {
+        const label = ts.displayPartsToString(p.displayParts);
+        const parameter = {
+          label,
+          documentation: ts.displayPartsToString(p.documentation)
+        };
+        signature.label += label;
+        if (signature.parameters) {
+          signature.parameters.push(parameter);
+        } else {
+          signature.parameters = [parameter];
+        }
+        if (i < a.length - 1) {
+          signature.label += ts.displayPartsToString(item.separatorDisplayParts);
+        }
+      });
+      signature.label += ts.displayPartsToString(item.suffixDisplayParts);
+      return signature;
+    });
+    return { signatures, activeSignature, activeParameter };
+  }
+  async doCodeAction(uri, range, context, formatOptions) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const start = document2.offsetAt(range.start);
+    const end = document2.offsetAt(range.end);
+    const errorCodes = context.diagnostics.map((diagnostic) => diagnostic.code).filter(Boolean).map(Number);
+    const codeFixes = await this._getCodeFixesAtPosition(uri, start, end, errorCodes, toTsFormatOptions(formatOptions));
+    return codeFixes.map((codeFix) => {
+      const action = {
+        title: codeFix.description,
+        kind: "quickfix"
+      };
+      if (codeFix.changes.length > 0) {
+        const edits = [];
+        for (const change of codeFix.changes) {
+          for (const { span, newText } of change.textChanges) {
+            edits.push({ range: createRangeFromDocumentSpan(document2, span), newText });
+          }
+        }
+        action.edit = { changes: { [uri]: edits } };
+      }
+      if (codeFix.commands?.length) {
+        const command = codeFix.commands[0];
+        action.command = {
+          title: command.title,
+          command: command.id,
+          arguments: command.arguments
+        };
+      }
+      return action;
+    });
+  }
+  async doRename(uri, position, newName) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const documentPosition = document2.offsetAt(position);
+    const renameInfo = this._languageService.getRenameInfo(uri, documentPosition, { allowRenameOfImportPath: true });
+    if (!renameInfo.canRename) {
+      return null;
+    }
+    const locations = this._languageService.findRenameLocations(uri, documentPosition, false, false, {
+      providePrefixAndSuffixTextForRename: false
+    });
+    if (!locations) {
+      return null;
+    }
+    const changes = {};
+    locations.map((loc) => {
+      const edits = changes[loc.fileName] || (changes[loc.fileName] = []);
+      const locDocument = this._getTextDocument(loc.fileName);
+      if (locDocument) {
+        edits.push({
+          range: createRangeFromDocumentSpan(locDocument, loc.textSpan),
+          newText: newName
+        });
+      }
+    });
+    return { changes };
+  }
+  async doFormat(uri, range, formatOptions, docText) {
+    const document2 = docText ? TextDocument2.create(uri, "typescript", 0, docText) : this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const formattingOptions = this._mergeFormatOptions(toTsFormatOptions(formatOptions));
+    let edits;
+    if (range) {
+      const start = document2.offsetAt(range.start);
+      const end = document2.offsetAt(range.end);
+      edits = this._languageService.getFormattingEditsForRange(uri, start, end, formattingOptions);
+    } else {
+      edits = this._languageService.getFormattingEditsForDocument(uri, formattingOptions);
+    }
+    return edits.map(({ span, newText }) => ({
+      range: createRangeFromDocumentSpan(document2, span),
+      newText
+    }));
+  }
+  async findDocumentSymbols(uri) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const toSymbol = (item, containerLabel) => {
+      const result = {
+        name: item.text,
+        kind: convertTsSymbolKind(item.kind),
+        range: createRangeFromDocumentSpan(document2, item.spans[0]),
+        selectionRange: createRangeFromDocumentSpan(document2, item.spans[0]),
+        children: item.childItems?.map((child) => toSymbol(child, item.text))
+      };
+      if (containerLabel) {
+        Reflect.set(result, "containerName", containerLabel);
+      }
+      return result;
+    };
+    const root = this._languageService.getNavigationTree(uri);
+    return root.childItems?.map((item) => toSymbol(item)) ?? null;
+  }
+  async findDefinition(uri, position) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const res = this._languageService.getDefinitionAndBoundSpan(uri, document2.offsetAt(position));
+    if (res) {
+      const { definitions, textSpan } = res;
+      if (definitions) {
+        return definitions.map((d) => {
+          const targetDocument = d.fileName === uri ? document2 : this._getTextDocument(d.fileName);
+          if (targetDocument) {
+            const range = createRangeFromDocumentSpan(targetDocument, d.textSpan);
+            const link = {
+              targetUri: d.fileName,
+              targetRange: range,
+              targetSelectionRange: void 0
+            };
+            if (d.contextSpan) {
+              link.targetRange = createRangeFromDocumentSpan(targetDocument, d.contextSpan);
+              link.targetSelectionRange = range;
+            }
+            if (d.kind === "script" || d.kind === "module") {
+              link.originSelectionRange = createRangeFromDocumentSpan(document2, {
+                start: textSpan.start + 1,
+                length: textSpan.length - 2
+              });
+            } else {
+              link.originSelectionRange = createRangeFromDocumentSpan(document2, textSpan);
+            }
+            return link;
+          }
+          return void 0;
+        }).filter((d) => d !== void 0);
+      }
+    }
+    return null;
+  }
+  async findReferences(uri, position) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const references = this._languageService.getReferencesAtPosition(uri, document2.offsetAt(position));
+    const result = [];
+    if (references) {
+      for (let entry of references) {
+        const entryDocument = this._getTextDocument(entry.fileName);
+        if (entryDocument) {
+          result.push({
+            uri: entryDocument.uri,
+            range: createRangeFromDocumentSpan(entryDocument, entry.textSpan)
+          });
+        }
+      }
+    }
+    return result;
+  }
+  async findDocumentHighlights(uri, position) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const highlights = this._languageService.getDocumentHighlights(uri, document2.offsetAt(position), [uri]);
+    const out = [];
+    for (const entry of highlights || []) {
+      for (const highlight of entry.highlightSpans) {
+        out.push({
+          range: createRangeFromDocumentSpan(document2, highlight.textSpan),
+          kind: highlight.kind === "writtenReference" ? DocumentHighlightKind.Write : DocumentHighlightKind.Text
+        });
+      }
+    }
+    return out;
+  }
+  async getFoldingRanges(uri) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    const spans = this._languageService.getOutliningSpans(uri);
+    const ranges = [];
+    for (const span of spans) {
+      const curr = createRangeFromDocumentSpan(document2, span.textSpan);
+      const startLine = curr.start.line;
+      const endLine = curr.end.line;
+      if (startLine < endLine) {
+        const foldingRange = { startLine, endLine };
+        const match = document2.getText(curr).match(/^\s*\/(?:(\/\s*#(?:end)?region\b)|(\*|\/))/);
+        if (match) {
+          foldingRange.kind = match[1] ? FoldingRangeKind.Region : FoldingRangeKind.Comment;
+        }
+        ranges.push(foldingRange);
+      }
+    }
+    return ranges;
+  }
+  async getSelectionRanges(uri, positions) {
+    const document2 = this._getTextDocument(uri);
+    if (!document2) {
+      return null;
+    }
+    function convertSelectionRange(selectionRange) {
+      const parent = selectionRange.parent ? convertSelectionRange(selectionRange.parent) : void 0;
+      return SelectionRange.create(createRangeFromDocumentSpan(document2, selectionRange.textSpan), parent);
+    }
+    return positions.map((position) => {
+      const range = this._languageService.getSmartSelectionRange(uri, document2.offsetAt(position));
+      return convertSelectionRange(range);
+    });
+  }
+  // #endregion
+  // #region public methods used by the host
+  async fetchHttpModule(specifier, containingFile) {
+    if (this._unknownImports.has(specifier)) {
+      const res = await cache.fetch(specifier);
+      res.body?.cancel();
+      this._unknownImports.delete(specifier);
+      if (!res.ok) {
+        this._badImports.add(specifier);
+      }
+      this._rollbackVersion(containingFile);
+      this.host.refreshDiagnostics(containingFile);
+    }
+  }
+  async updateCompilerOptions(options) {
+    const { compilerOptions, importMap, types } = options;
+    if (compilerOptions) {
+      this._compilerOptions = ts.convertCompilerOptionsFromJson(compilerOptions, ".").options;
+      this._updateJsxImportSource();
+    }
+    if (importMap) {
+      this._importMap = importMap;
+      this._importMapVersion++;
+      this._isBlankImportMap = isBlankImportMap(importMap);
+      this._updateJsxImportSource();
+    }
+    if (types) {
+      for (const uri of Object.keys(this._types)) {
+        if (!(uri in types)) {
+          this.removeDocumentCache(uri);
+        }
+      }
+      this._types = types;
+    }
+  }
+  // #endregion
+  // #region private methods
+  _getCompletionsAtPosition(fileName, position) {
+    const completions = this._languageService.getCompletionsAtPosition(
+      fileName,
+      position,
+      {
+        quotePreference: this._formatOptions?.quotePreference,
+        allowRenameOfImportPath: true,
+        importModuleSpecifierEnding: "js",
+        importModuleSpecifierPreference: "shortest",
+        includeCompletionsForModuleExports: true,
+        includeCompletionsForImportStatements: true,
+        includePackageJsonAutoImports: "off",
+        organizeImportsIgnoreCase: false
+      }
+    );
+    if (completions) {
+      const autoImports = /* @__PURE__ */ new Set();
+      completions.entries = completions.entries.filter((entry) => {
+        const { data } = entry;
+        if (!data || !data.fileName || !isDts(data.fileName)) {
+          return true;
+        }
+        const { moduleSpecifier, exportName } = data;
+        if (moduleSpecifier && (moduleSpecifier in this._importMap.imports || this._typesMappings.has(moduleSpecifier))) {
+          autoImports.add(exportName + " " + moduleSpecifier);
+          return true;
+        }
+        const specifier = this._getSpecifierFromDts(data.fileName);
+        if (specifier && !autoImports.has(exportName + " " + specifier)) {
+          autoImports.add(exportName + " " + specifier);
+          return true;
+        }
+        return false;
+      });
+      return completions;
+    }
+    return void 0;
+  }
+  _getCompletionEntryDetails(fileName, position, entryName, data) {
+    try {
+      const detail = this._languageService.getCompletionEntryDetails(
+        fileName,
+        position,
+        entryName,
+        {
+          insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: true,
+          semicolons: ts.SemicolonPreference.Insert
+        },
+        void 0,
+        void 0,
+        data
+      );
+      detail?.codeActions?.forEach((action) => {
+        if (action.description.startsWith("Add import from ")) {
+          const specifier = action.description.slice(17, -1);
+          const newSpecifier = this._getSpecifierFromDts(isDts(specifier) ? specifier : specifier + ".d.ts");
+          if (newSpecifier) {
+            action.description = `Add type import from "${newSpecifier}"`;
+            action.changes.forEach((change) => {
+              change.textChanges.forEach((textChange) => {
+                textChange.newText = textChange.newText.replace(
+                  specifier,
+                  newSpecifier
+                );
+              });
+            });
+          }
+        }
+      });
+      return detail;
+    } catch (error) {
+      return;
+    }
+  }
+  _getQuickInfoAtPosition(fileName, position) {
+    const info = this._languageService.getQuickInfoAtPosition(fileName, position);
+    if (!info) {
+      return;
+    }
+    const { kind, kindModifiers, displayParts, textSpan } = info;
+    if (kind === ts.ScriptElementKind.moduleElement && displayParts?.length === 3) {
+      const moduleName = displayParts[2].text;
+      if (moduleName.startsWith('"file:') && fileName.startsWith("file:")) {
+        const literalText = this.getModel(fileName)?.getValue().substring(
+          textSpan.start,
+          textSpan.start + textSpan.length
+        );
+        if (literalText) {
+          try {
+            const specifier = JSON.parse(literalText);
+            displayParts[2].text = '"' + new URL(specifier, fileName).pathname + '"';
+          } catch (error) {
+          }
+        }
+      } else if (
+        // show module url for `http:` specifiers instead of the types url
+        kindModifiers === "declare" && moduleName.startsWith('"http')
+      ) {
+        const specifier = JSON.parse(moduleName);
+        for (const [url, dts] of this._typesMappings) {
+          if (specifier + ".d.ts" === dts) {
+            displayParts[2].text = '"' + url + '"';
+            info.tags = [{
+              name: "types",
+              text: [{ kind: "text", text: dts }]
+            }];
+            const { pathname, hostname } = new URL(url);
+            if (isEsmshHost(hostname)) {
+              const pathSegments = pathname.split("/").slice(1);
+              if (/^v\d+$/.test(pathSegments[0])) {
+                pathSegments.shift();
+              }
+              let scope = "";
+              let pkgName = pathSegments.shift();
+              if (pkgName?.startsWith("@")) {
+                scope = pkgName;
+                pkgName = pathSegments.shift();
+              }
+              if (!pkgName) {
+                continue;
+              }
+              const npmPkgId = [scope, pkgName.split("@")[0]].filter(Boolean).join("/");
+              const npmPkgUrl = `https://www.npmjs.com/package/${npmPkgId}`;
+              info.tags.unshift({
+                name: "npm",
+                text: [{ kind: "text", text: `[${npmPkgId}](${npmPkgUrl})` }]
+              });
+            }
+            break;
+          }
+        }
+      }
+    }
+    return info;
+  }
+  async _getCodeFixesAtPosition(fileName, start, end, errorCodes, formatOptions) {
+    let span = [start + 1, end - 1];
+    if (start === end && (this._redirectedImports.length > 0 || errorCodes.includes(2307))) {
+      const a = this._languageService.getReferencesAtPosition(fileName, start);
+      if (a && a.length > 0) {
+        const b = a[0];
+        span = [b.textSpan.start, b.textSpan.start + b.textSpan.length];
+      }
+    }
+    const fixes = [];
+    if (this._redirectedImports.length > 0) {
+      const i = this._redirectedImports.findIndex(([modelUrl, node]) => {
+        return fileName === modelUrl && node.getStart() === span[0] - 1 && node.getEnd() === span[1] + 1;
+      });
+      if (i >= 0) {
+        const [_, node, url] = this._redirectedImports[i];
+        const fixName = `Update module specifier to ${url}`;
+        fixes.push({
+          fixName,
+          description: fixName,
+          changes: [{
+            fileName,
+            textChanges: [{
+              span: { start: node.getStart(), length: node.getWidth() },
+              newText: JSON.stringify(url)
+            }]
+          }]
+        });
+      }
+    }
+    if (errorCodes.includes(2307)) {
+      const specifier = this.getModel(fileName)?.getValue().slice(...span);
+      if (specifier) {
+        if (this._unknownImports.has(specifier)) {
+          const fixName = `Fetch module from '${specifier}'`;
+          fixes.push({
+            fixName,
+            description: fixName,
+            changes: [],
+            commands: [{
+              id: "ts:fetch_http_module",
+              title: "Fetch the module from internet",
+              arguments: [specifier, fileName]
+            }]
+          });
+        }
+      }
+    }
+    try {
+      const tsFixes = this._languageService.getCodeFixesAtPosition(
+        fileName,
+        start,
+        end,
+        errorCodes,
+        this._mergeFormatOptions(formatOptions),
+        {}
+      );
+      return fixes.concat(tsFixes);
+    } catch (err) {
+      return fixes;
+    }
+  }
+  /** rollback the version to force reinvoke `resolveModuleNameLiterals` method. */
+  _rollbackVersion(fileName) {
+    const model = this.getModel(fileName);
+    if (model) {
+      model._versionId--;
+    }
+  }
+  _getScriptText(fileName) {
+    return libs[fileName] ?? libs[`lib.${fileName}.d.ts`] ?? this._types[fileName]?.content ?? this._httpLibs.get(fileName) ?? this._httpModules.get(fileName) ?? this._httpTsModules.get(fileName) ?? this.getModel(fileName)?.getValue();
+  }
+  _getTextDocument(uri) {
+    const doc = this.getTextDocument(uri);
+    if (doc) {
+      return doc;
+    }
+    if (uri.startsWith("http://") || uri.startsWith("https://")) {
+      const docCache = this._httpDocumentCache;
+      if (docCache.has(uri)) {
+        return docCache.get(uri);
+      }
+      const scriptText = this._getScriptText(uri);
+      if (scriptText) {
+        const doc2 = TextDocument2.create(uri, "typescript", 1, scriptText);
+        docCache.set(uri, doc2);
+        return doc2;
+      }
+    }
+    return null;
+  }
+  _markHttpLib(url, dtsContent) {
+    this._httpLibs.set(url, dtsContent);
+    setTimeout(() => {
+      const referencedFiles = this._languageService.getProgram()?.getSourceFile(url)?.referencedFiles ?? [];
+      referencedFiles.forEach((ref) => {
+        const refUrl = new URL(ref.fileName, url).href;
+        if (isDts(refUrl) && !this._fetchPromises.has(refUrl) && !this._httpLibs.has(refUrl) && !this._badImports.has(refUrl)) {
+          this._fetchPromises.set(
+            refUrl,
+            cache.fetch(refUrl).then(async (res) => {
+              if (res.ok) {
+                this._httpLibs.set(refUrl, await res.text());
+              } else {
+                this._badImports.add(refUrl);
+              }
+            }).catch((err) => {
+              console.error(`Failed to fetch types: ${refUrl}`, err);
+            }).finally(() => {
+              this._fetchPromises.delete(refUrl);
+            })
+          );
+        }
+      });
+    });
+  }
+  _getSpecifierFromDts(filename) {
+    for (const [specifier, dts] of this._typesMappings) {
+      if (filename === dts) {
+        if (!this._isBlankImportMap) {
+          for (const [key, value] of Object.entries(this._importMap.imports)) {
+            if (value === specifier && key !== "@jsxRuntime") {
+              return key;
+            }
+          }
+        }
+        return specifier;
+      }
+    }
+  }
+  _convertDiagnostic(document2, diagnostic) {
+    const tags = [];
+    if (diagnostic.reportsUnnecessary) {
+      tags.push(DiagnosticTag.Unnecessary);
+    }
+    if (diagnostic.reportsDeprecated) {
+      tags.push(DiagnosticTag.Deprecated);
+    }
+    return {
+      range: createRangeFromDocumentSpan(document2, diagnostic),
+      code: diagnostic.code,
+      severity: convertTsDiagnosticCategory(diagnostic.category),
+      message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+      source: diagnostic.source,
+      tags,
+      relatedInformation: this._convertRelatedInformation(document2, diagnostic.relatedInformation)
+    };
+  }
+  _convertRelatedInformation(document2, relatedInformation) {
+    if (!relatedInformation) {
+      return [];
+    }
+    const result = [];
+    relatedInformation.forEach((info) => {
+      const doc = info.file ? this._getTextDocument(info.file.fileName) : document2;
+      if (!doc) {
+        return;
+      }
+      const start = doc.positionAt(info.start ?? 0);
+      const end = doc.positionAt((info.start ?? 0) + (info.length ?? 1));
+      result.push({
+        location: {
+          uri: document2.uri,
+          range: Range.create(start, end)
+        },
+        message: ts.flattenDiagnosticMessageText(info.messageText, "\n")
+      });
+    });
+    return result;
+  }
+  _getJsxImportSource() {
+    const { imports } = this._importMap;
+    for (const specifier of ["@jsxRuntime", "@jsxImportSource", "preact", "react"]) {
+      if (specifier in imports) {
+        return imports[specifier];
+      }
+    }
+    return void 0;
+  }
+  _updateJsxImportSource() {
+    if (!this._compilerOptions.jsxImportSource) {
+      const jsxImportSource = this._getJsxImportSource();
+      if (jsxImportSource) {
+        this._compilerOptions.jsx = ts.JsxEmit.React;
+        this._compilerOptions.jsxImportSource = jsxImportSource;
+      }
+    }
+  }
+  _mergeFormatOptions(formatOptions) {
+    return { ...this._formatOptions, ...formatOptions };
+  }
+  _isJsxImportUrl(url) {
+    const jsxImportUrl = this._getJsxImportSource();
+    if (jsxImportUrl) {
+      return url === jsxImportUrl + "/jsx-runtime" || url === jsxImportUrl + "/jsx-dev-runtime";
+    }
+    return false;
+  }
+  // #endregion
+};
+function getScriptExtension(url) {
+  const pathname = typeof url === "string" ? pathToUrl(url).pathname : url.pathname;
+  const basename = pathname.substring(pathname.lastIndexOf("/") + 1);
+  const dotIndex = basename.lastIndexOf(".");
+  if (dotIndex === -1) {
+    return null;
+  }
+  const ext = basename.substring(dotIndex + 1);
+  switch (ext) {
+    case "ts":
+      return basename.endsWith(".d.ts") ? ".d.ts" : ".ts";
+    case "mts":
+      return basename.endsWith(".d.mts") ? ".d.mts" : ".mts";
+    case "cts":
+      return basename.endsWith(".d.cts") ? ".d.cts" : ".cts";
+    case "tsx":
+      return ".tsx";
+    case "js":
+      return ".js";
+    case "mjs":
+      return ".js";
+    case "cjs":
+      return ".cjs";
+    case "jsx":
+      return ".jsx";
+    case "json":
+      return ".json";
+    default:
+      return ".js";
+  }
+}
+function isHttpUrl(url) {
+  return url.startsWith("http://") || url.startsWith("https://");
+}
+function isRelativePath(path) {
+  return path.startsWith("./") || path.startsWith("../");
+}
+function isEsmshHost(hostname) {
+  return hostname === "esm.sh" || hostname.endsWith(".esm.sh");
+}
+var regexpPackagePath = /\/((@|gh\/|pr\/|jsr\/@)[\w\.\-]+\/)?[\w\.\-]+@(\d+(\.\d+){0,2}(\-[\w\.]+)?|next|canary|rc|beta|latest)$/;
+function isWellKnownCDNURL(url) {
+  const { pathname } = url;
+  return regexpPackagePath.test(pathname);
+}
+function isDts(fileName) {
+  return fileName.endsWith(".d.ts") || fileName.endsWith(".d.mts") || fileName.endsWith(".d.cts");
+}
+function pathToUrl(path) {
+  return new URL(path, "file:///");
+}
+function createRangeFromDocumentSpan(document2, span) {
+  if (typeof span.start === "undefined") {
+    const pos = document2.positionAt(0);
+    return Range.create(pos, pos);
+  }
+  const start = document2.positionAt(span.start);
+  const end = document2.positionAt(span.start + (span.length ?? 0));
+  return Range.create(start, end);
+}
+function convertTsCompletionItemKind(kind) {
+  const ScriptElementKind = ts.ScriptElementKind;
+  switch (kind) {
+    case ScriptElementKind.primitiveType:
+    case ScriptElementKind.keyword:
+      return CompletionItemKind.Keyword;
+    case ScriptElementKind.constElement:
+    case ScriptElementKind.letElement:
+    case ScriptElementKind.variableElement:
+    case ScriptElementKind.localVariableElement:
+    case ScriptElementKind.alias:
+    case ScriptElementKind.parameterElement:
+      return CompletionItemKind.Variable;
+    case ScriptElementKind.memberVariableElement:
+    case ScriptElementKind.memberGetAccessorElement:
+    case ScriptElementKind.memberSetAccessorElement:
+      return CompletionItemKind.Field;
+    case ScriptElementKind.functionElement:
+    case ScriptElementKind.localFunctionElement:
+      return CompletionItemKind.Function;
+    case ScriptElementKind.memberFunctionElement:
+    case ScriptElementKind.constructSignatureElement:
+    case ScriptElementKind.callSignatureElement:
+    case ScriptElementKind.indexSignatureElement:
+      return CompletionItemKind.Method;
+    case ScriptElementKind.enumElement:
+      return CompletionItemKind.Enum;
+    case ScriptElementKind.enumMemberElement:
+      return CompletionItemKind.EnumMember;
+    case ScriptElementKind.moduleElement:
+    case ScriptElementKind.externalModuleName:
+      return CompletionItemKind.Module;
+    case ScriptElementKind.classElement:
+    case ScriptElementKind.typeElement:
+      return CompletionItemKind.Class;
+    case ScriptElementKind.interfaceElement:
+      return CompletionItemKind.Interface;
+    case ScriptElementKind.warning:
+      return CompletionItemKind.Text;
+    case ScriptElementKind.scriptElement:
+      return CompletionItemKind.File;
+    case ScriptElementKind.directory:
+      return CompletionItemKind.Folder;
+    case ScriptElementKind.string:
+      return CompletionItemKind.Constant;
+    default:
+      return CompletionItemKind.Property;
+  }
+}
+function convertTsSymbolKind(kind) {
+  const Kind = ts.ScriptElementKind;
+  switch (kind) {
+    case Kind.memberVariableElement:
+    case Kind.memberGetAccessorElement:
+    case Kind.memberSetAccessorElement:
+      return SymbolKind.Field;
+    case Kind.functionElement:
+    case Kind.localFunctionElement:
+      return SymbolKind.Function;
+    case Kind.memberFunctionElement:
+    case Kind.constructSignatureElement:
+    case Kind.callSignatureElement:
+    case Kind.indexSignatureElement:
+      return SymbolKind.Method;
+    case Kind.enumElement:
+      return SymbolKind.Enum;
+    case Kind.enumMemberElement:
+      return SymbolKind.EnumMember;
+    case Kind.moduleElement:
+    case Kind.externalModuleName:
+      return SymbolKind.Module;
+    case Kind.classElement:
+    case Kind.typeElement:
+      return SymbolKind.Class;
+    case Kind.interfaceElement:
+      return SymbolKind.Interface;
+    case Kind.scriptElement:
+      return SymbolKind.File;
+    case Kind.string:
+      return SymbolKind.Constant;
+    default:
+      return SymbolKind.Variable;
+  }
+}
+function convertTsDiagnosticCategory(category) {
+  switch (category) {
+    case ts.DiagnosticCategory.Error:
+      return DiagnosticSeverity.Error;
+    case ts.DiagnosticCategory.Message:
+      return DiagnosticSeverity.Information;
+    case ts.DiagnosticCategory.Warning:
+      return DiagnosticSeverity.Warning;
+    case ts.DiagnosticCategory.Suggestion:
+      return DiagnosticSeverity.Hint;
+  }
+  return DiagnosticSeverity.Information;
+}
+function tagStringify(tag) {
+  let tagLabel = `*@${tag.name}*`;
+  if (tag.name === "param" && tag.text) {
+    const [paramName, ...rest] = tag.text;
+    tagLabel += `\`${paramName.text}\``;
+    if (rest.length > 0) tagLabel += ` \u2014 ${rest.map((r) => r.text).join(" ")}`;
+  } else if (Array.isArray(tag.text)) {
+    tagLabel += ` \u2014 ${tag.text.map((r) => r.text).join("")}`;
+  } else if (tag.text) {
+    tagLabel += ` \u2014 ${tag.text}`;
+  }
+  return tagLabel;
+}
+function toTsSignatureHelpTriggerReason(context) {
+  switch (context.triggerKind) {
+    case 3:
+      return context.isRetrigger ? { kind: "retrigger" } : { kind: "invoked" };
+    case 2:
+      if (context.triggerCharacter) {
+        if (context.isRetrigger) {
+          return {
+            kind: "retrigger",
+            triggerCharacter: context.triggerCharacter
+          };
+        } else {
+          return {
+            kind: "characterTyped",
+            triggerCharacter: context.triggerCharacter
+          };
+        }
+      } else {
+        return { kind: "invoked" };
+      }
+    case 1:
+    default:
+      return { kind: "invoked" };
+  }
+}
+function toTsFormatOptions({ tabSize, trimTrailingWhitespace, insertSpaces }) {
+  return {
+    tabSize,
+    trimTrailingWhitespace,
+    indentSize: tabSize,
+    convertTabsToSpaces: insertSpaces,
+    insertSpaceAfterCommaDelimiter: insertSpaces,
+    insertSpaceAfterSemicolonInForStatements: insertSpaces,
+    insertSpaceBeforeAndAfterBinaryOperators: insertSpaces,
+    insertSpaceAfterKeywordsInControlFlowStatements: insertSpaces,
+    insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: insertSpaces
+  };
+}
+initializeWorker(TypeScriptWorker);
+export {
+  TypeScriptWorker
+};