@marko/language-server 0.10.1 → 0.12.1

package/dist/index.js

@@ -1,171 +1,779 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const node_1 = require("vscode-languageserver/node");
-const vscode_uri_1 = require("vscode-uri");
-const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
-const prettier = (0, tslib_1.__importStar)(require("prettier"));
-const util_1 = require("util");
-const compiler_1 = require("./utils/compiler");
-const htmljs_parser_1 = require("./utils/htmljs-parser");
-const completionTypes = (0, tslib_1.__importStar)(require("./utils/completions"));
-const definitionTypes = (0, tslib_1.__importStar)(require("./utils/definitions"));
-if (typeof require !== "undefined" &&
-    require.extensions &&
-    !(".ts" in require.extensions)) {
-    // Prevent compiler hooks written in typescript to explode the language server.
-    require.extensions[".ts"] = undefined;
-}
-const cacheForCompiler = new WeakMap();
-const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
-const prevDiagnostics = new WeakMap();
-const diagnosticTimeouts = new WeakMap();
-const documents = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
-const markoErrorRegExp = /^(.+?)(?:\((\d+)(?:\s*,\s*(\d+))?\))?: (.*)$/gm;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+
+// src/index.ts
+var import_node = require("vscode-languageserver/node");
+var import_vscode_uri6 = require("vscode-uri");
+var import_vscode_languageserver_textdocument3 = require("vscode-languageserver-textdocument");
+var prettier = __toESM(require("prettier"));
+var markoPrettier = __toESM(require("prettier-plugin-marko"));
+var import_util = require("util");
+
+// src/utils/compiler.ts
+var import_path = __toESM(require("path"));
+var import_vscode_uri = require("vscode-uri");
+var import_resolve_from = __toESM(require("resolve-from"));
+var import_lasso_package_root = __toESM(require("lasso-package-root"));
+var builtinCompiler = __toESM(require("@marko/compiler"));
+var builtinTranslator = __toESM(require("@marko/translator-default"));
+builtinCompiler.configure({ translator: builtinTranslator });
+var compilerAndTranslatorForDoc = /* @__PURE__ */ new WeakMap();
+function getCompilerAndTranslatorForDoc(doc) {
+  let compilerAndTranslator = compilerAndTranslatorForDoc.get(doc);
+  if (!compilerAndTranslator) {
+    compilerAndTranslatorForDoc.set(doc, compilerAndTranslator = loadCompiler(import_path.default.dirname(import_vscode_uri.URI.parse(doc.uri).fsPath)));
+  }
+  return compilerAndTranslator;
+}
+function getTagLibLookup(document) {
+  try {
+    const { compiler, translator } = getCompilerAndTranslatorForDoc(document);
+    return compiler.taglib.buildLookup(import_vscode_uri.URI.parse(document.uri).fsPath, translator);
+  } catch {
+  }
+}
+function loadCompiler(dir) {
+  const rootDir = import_lasso_package_root.default.getRootDir(dir);
+  const pkgPath = rootDir && import_resolve_from.default.silent(rootDir, "@marko/compiler/package.json");
+  const pkg = pkgPath && require(pkgPath);
+  if (pkg && /^5\./.test(pkg.version)) {
+    try {
+      let translator = [].concat(Object.keys(pkg.dependencies), Object.keys(pkg.peerDependencies), Object.keys(pkg.devDependencies)).find((name) => /^marko$|^(@\/marko\/|marko-)translator-/.test(name));
+      if (translator === "marko" || !translator) {
+        translator = require((0, import_resolve_from.default)(dir, "@marko/compiler/config")).translator;
+      }
+      require((0, import_resolve_from.default)(dir, translator));
+      return {
+        compiler: require((0, import_resolve_from.default)(dir, "@marko/compiler")),
+        translator
+      };
+    } catch {
+    }
+  }
+  return {
+    compiler: builtinCompiler,
+    translator: builtinTranslator
+  };
+}
+
+// src/utils/htmljs-parser.ts
+var import_htmljs_parser = require("htmljs-parser");
+var SUPPORTED_STYLE_LANGS = {
+  css: true,
+  scss: true,
+  less: true
+};
+function parseUntilOffset(options) {
+  const { offset, text, taglib, includeErrors } = options;
+  let result = null;
+  let parentTag = null;
+  const parser = (0, import_htmljs_parser.createParser)({
+    onError: includeErrors && finish,
+    onScriptlet: finish,
+    onPlaceholder: finish,
+    onOpenTagName(ev) {
+      if (parentTag) {
+        ev.parent = parentTag;
+      }
+      if (!ev.concise) {
+        ev.pos += 1;
+      }
+      ev.endPos = ev.pos + ev.tagName.length;
+      parentTag = ev;
+      finish(ev);
+    },
+    onOpenTag(ev) {
+      ev.parent = parentTag.parent;
+      parentTag = ev;
+      if (ev.tagName === "style") {
+        const firstAttr = ev.attributes[0];
+        const isBlock = firstAttr && firstAttr.name.startsWith("{");
+        if (isBlock) {
+          const content = firstAttr.name.slice(1, -1);
+          const pos = text.indexOf(content, ev.tagNameEndPos);
+          const endPos = pos + content.length;
+          const requestedLanguage = ev.shorthandClassNames && ev.shorthandClassNames[0].rawParts[0] && ev.shorthandClassNames[0].rawParts[0].text;
+          const language = requestedLanguage && SUPPORTED_STYLE_LANGS[requestedLanguage] ? requestedLanguage : "css";
+          finish({
+            type: "styleContent",
+            language,
+            block: true,
+            content: text.slice(pos, endPos),
+            pos,
+            endPos
+          });
+          return;
+        }
+      }
+      let attrEndPos = ev.tagNameEndPos;
+      for (const attr of ev.attributes) {
+        if (!attr.name) {
+          if (attr.value !== void 0) {
+            attrEndPos += attr.value.length;
+          }
+          continue;
+        }
+        if (attr.name.slice(0, 3) === "...") {
+          attrEndPos = attr.argument ? attr.argument.endPos + 1 : attr.endPos;
+          continue;
+        }
+        const attrStartPos = text.indexOf(attr.name, attrEndPos);
+        const match = /:(.*)$/.exec(attr.name);
+        const modifier = match && match[1];
+        let name = attr.name;
+        if (modifier) {
+          name = name.slice(0, name.length - modifier.length - 1);
+          const modifierStartPos = attrStartPos + name.length;
+          const modifierEndPos = modifierStartPos + modifier.length + 1;
+          if (finish({
+            type: "attributeModifier",
+            tag: ev,
+            name,
+            modifier,
+            pos: modifierStartPos,
+            endPos: modifierEndPos
+          })) {
+            return;
+          }
+        }
+        const attrNameEndPos = attrStartPos + name.length;
+        if (finish({
+          type: "attributeName",
+          tag: ev,
+          name,
+          pos: attrStartPos,
+          endPos: attrNameEndPos
+        })) {
+          return;
+        }
+        if (attr.value) {
+          attrEndPos = attr.endPos;
+          const valueStartPos = attr.pos + 1;
+          if (finish({
+            type: "attributeValue",
+            tag: ev,
+            name,
+            value: text.slice(valueStartPos, attrEndPos),
+            pos: valueStartPos,
+            endPos: attr.endPos
+          })) {
+            break;
+          }
+        } else {
+          attrEndPos = attr.argument ? attr.argument.endPos + 1 : attr.endPos;
+        }
+      }
+      finish(ev);
+    },
+    onText(ev) {
+      ev.endPos = parser.pos;
+      ev.pos = ev.endPos - ev.value.length;
+      if (parentTag) {
+        ev.parent = parentTag;
+        if (parentTag.tagName === "style") {
+          finish({
+            type: "styleContent",
+            language: "css",
+            block: false,
+            content: ev.value,
+            pos: ev.pos,
+            endPos: ev.endPos
+          });
+          return;
+        }
+      }
+      finish(ev);
+    },
+    onCloseTag(ev) {
+      parentTag = parentTag && parentTag.parent;
+      finish(ev);
+    }
+  }, {
+    isOpenTagOnly(ev) {
+      const tagDef = taglib.getTag(ev);
+      return tagDef && tagDef.openTagOnly;
+    }
+  });
+  try {
+    parser.parse(`${text}
+`);
+  } catch (err) {
+    return includeErrors ? {
+      type: "error",
+      code: "UNEXPECTED_TOKEN",
+      message: err.message,
+      pos: parser.pos,
+      endPos: parser.pos
+    } : null;
+  }
+  return result;
+  function finish(event) {
+    const { type, pos, endPos } = event;
+    if (!result && (type === "error" || pos != null && pos <= offset && endPos != null && endPos >= offset)) {
+      result = event;
+      parser.end();
+      return true;
+    }
+    return false;
+  }
+}
+
+// src/utils/completions/index.ts
+var completions_exports = {};
+__export(completions_exports, {
+  attributeModifier: () => attributeModifier,
+  attributeName: () => attributeName,
+  closeTag: () => closeTag,
+  openTag: () => openTag,
+  openTagName: () => openTagName,
+  styleContent: () => styleContent
+});
+
+// src/utils/completions/types/attributeModifier.ts
+var import_vscode_languageserver = require("vscode-languageserver");
+function attributeModifier(_taglib, _document, _params, _event) {
+  return import_vscode_languageserver.CompletionList.create([
+    {
+      label: "scoped",
+      kind: import_vscode_languageserver.CompletionItemKind.Keyword,
+      detail: "Use to prefix with a unique ID"
+    },
+    {
+      label: "no-update",
+      kind: import_vscode_languageserver.CompletionItemKind.Keyword,
+      detail: "Use to skip future updates to this attribute"
+    }
+  ], true);
+}
+
+// src/utils/completions/types/attributeName.ts
+var import_vscode_languageserver3 = require("vscode-languageserver");
+
+// src/utils/utils.ts
+var import_fs = __toESM(require("fs"));
+var import_vscode_uri2 = require("vscode-uri");
+var import_vscode_languageserver2 = require("vscode-languageserver");
+var import_vscode_languageserver_textdocument = require("vscode-languageserver-textdocument");
+var START_OF_FILE = import_vscode_languageserver2.Range.create(import_vscode_languageserver2.Position.create(0, 0), import_vscode_languageserver2.Position.create(0, 0));
+function findNonControlFlowParent(tag) {
+  let parent = tag.parent;
+  while (parent) {
+    if (!/^(?:else-)?if|else|for|while$/.test(parent.tagName)) {
+      return parent;
+    }
+    parent = parent.parent;
+  }
+  return null;
+}
+function rangeFromEvent(document, event) {
+  return import_vscode_languageserver2.Range.create(document.positionAt(event.pos), document.positionAt(event.endPos));
+}
+function createTextDocument(filename) {
+  const uri = import_vscode_uri2.URI.file(filename).toString();
+  const content = import_fs.default.readFileSync(filename, "utf-8");
+  return import_vscode_languageserver_textdocument.TextDocument.create(uri, "plaintext", 0, content);
+}
+function shiftCompletionRanges(list, offset) {
+  list.items.forEach((item) => {
+    if (item.additionalTextEdits) {
+      item.additionalTextEdits.forEach((edit) => shiftRange(edit.range, offset));
+    }
+    if (item.textEdit) {
+      shiftEdit(item.textEdit, offset);
+    }
+  });
+  return list;
+}
+function shiftEdit(edit, offset) {
+  if (import_vscode_languageserver2.TextEdit.is(edit)) {
+    shiftRange(edit.range, offset);
+  } else {
+    shiftRange(edit.insert, offset);
+    shiftRange(edit.replace, offset);
+  }
+}
+function shiftRange(range, offset) {
+  if (range) {
+    shiftPosition(range.start, offset);
+    shiftPosition(range.end, offset);
+  }
+}
+function shiftPosition(pos, offset) {
+  if (pos.line === 0) {
+    pos.character += offset.character;
+  }
+  pos.line += offset.line;
+  return pos;
+}
+
+// src/utils/completions/types/attributeName.ts
+function attributeName(taglib, document, _params, event) {
+  const completions = [];
+  const attrNameRange = rangeFromEvent(document, event);
+  const tagDef = !event.tag.tagNameExpression && taglib.getTag(event.tag.tagName);
+  const tagName = tagDef && tagDef.name || "*";
+  const nestedTagAttrs = {};
+  const neverAttrs = /* @__PURE__ */ new Set();
+  if (tagDef && tagDef.nestedTags) {
+    for (const key in tagDef.nestedTags) {
+      const nestedTagDef = tagDef.nestedTags[key];
+      nestedTagAttrs[nestedTagDef.targetProperty] = true;
+    }
+  }
+  taglib.forEachAttribute(tagName, (attr) => {
+    if (attr.type === "never") {
+      neverAttrs.add(attr.name);
+    }
+  });
+  taglib.forEachAttribute(tagName, (attr, parent) => {
+    if (attr.deprecated || nestedTagAttrs[attr.name] || attr.name === "*" || neverAttrs.has(attr.name) || attr.name[0] === "_" && /\/node_modules\//.test(attr.filePath || parent.filePath)) {
+      return;
+    }
+    const type = attr.type || (attr.html ? "string" : null);
+    const documentation = {
+      kind: import_vscode_languageserver3.MarkupKind.Markdown,
+      value: attr.description || ""
+    };
+    let label = attr.name;
+    let snippet = attr.name;
+    if (attr.enum) {
+      snippet += `="\${1|${attr.enum.join()}|}"$0`;
+    } else {
+      switch (type) {
+        case "string":
+          snippet += '="$1"$0';
+          break;
+        case "function":
+          snippet += "=($1)$0";
+          break;
+        case "statement":
+        case "boolean":
+        case "flag":
+          break;
+        default:
+          snippet += "=";
+          break;
+      }
+    }
+    const autocomplete = attr.autocomplete && Array.isArray(attr.autocomplete) ? attr.autocomplete[0] : attr.autocomplete;
+    if (autocomplete) {
+      label = autocomplete.displayText || label;
+      snippet = autocomplete.snippet || snippet;
+      if (autocomplete.descriptionMoreURL) {
+        if (documentation.value) {
+          documentation.value += `
+
+`;
+        }
+        documentation.value += `[More Info](${autocomplete.descriptionMoreURL})`;
+      }
+    }
+    completions.push({
+      label,
+      documentation: documentation.value ? documentation : void 0,
+      kind: import_vscode_languageserver3.CompletionItemKind.Property,
+      insertTextFormat: import_vscode_languageserver3.InsertTextFormat.Snippet,
+      textEdit: import_vscode_languageserver3.TextEdit.replace(attrNameRange, snippet)
+    });
+  });
+  return import_vscode_languageserver3.CompletionList.create(completions, true);
+}
+
+// src/utils/completions/types/closeTag.ts
+var import_vscode_languageserver4 = require("vscode-languageserver");
+function closeTag(_taglib, document, _params, event) {
+  if (event.tagName[0] === "$") {
+    return;
+  }
+  const closingTagStr = `</${event.tagName}>`;
+  return import_vscode_languageserver4.CompletionList.create([
+    {
+      label: closingTagStr,
+      kind: import_vscode_languageserver4.CompletionItemKind.Class,
+      insertTextFormat: import_vscode_languageserver4.InsertTextFormat.Snippet,
+      textEdit: import_vscode_languageserver4.TextEdit.replace(rangeFromEvent(document, event), closingTagStr)
+    }
+  ], true);
+}
+
+// src/utils/completions/types/openTag.ts
+var import_vscode_languageserver5 = require("vscode-languageserver");
+function openTag(_taglib, _document, params, event) {
+  const triggerCharacter = params.context && params.context.triggerCharacter;
+  if (triggerCharacter !== ">" || event.openTagOnly || event.selfClosed) {
+    return;
+  }
+  const closingTagStr = `</${event.tagName[0] === "$" ? "" : event.tagName}>`;
+  return import_vscode_languageserver5.CompletionList.create([
+    {
+      label: closingTagStr,
+      kind: import_vscode_languageserver5.CompletionItemKind.Class,
+      insertTextFormat: import_vscode_languageserver5.InsertTextFormat.Snippet,
+      insertText: `
+	$0
+${closingTagStr}`
+    }
+  ], true);
+}
+
+// src/utils/completions/types/openTagName.ts
+var import_path2 = __toESM(require("path"));
+var import_vscode_uri3 = require("vscode-uri");
+var import_vscode_languageserver6 = require("vscode-languageserver");
+function openTagName(taglib, document, params, event) {
+  const { fsPath: currentTemplateFilePath } = import_vscode_uri3.URI.parse(document.uri);
+  let tags;
+  const triggerCharacter = params.context && params.context.triggerCharacter || event.tagName[0];
+  const isAttributeTag = triggerCharacter === "@";
+  const tagNameRange = rangeFromEvent(document, event);
+  if (isAttributeTag) {
+    const parentTag = findNonControlFlowParent(event);
+    const parentTagDef = parentTag && !parentTag.tagNameExpression && taglib.getTag(parentTag.tagName);
+    tags = parentTagDef && parentTagDef.nestedTags && Object.values(parentTagDef.nestedTags) || [];
+  } else {
+    tags = taglib.getTagsSorted().filter((it) => !it.isNestedTag);
+  }
+  return import_vscode_languageserver6.CompletionList.create(tags.filter((it) => !it.deprecated).filter((it) => it.name !== "*").filter((it) => /^[^_]/.test(it.name) || !/\/node_modules\//.test(it.filePath)).map((it) => {
+    let label = it.isNestedTag ? `@${it.name}` : it.name;
+    const fileForTag = it.template || it.renderer || it.filePath;
+    const fileURIForTag = import_vscode_uri3.URI.file(fileForTag).toString();
+    const nodeModuleMatch = /\/node_modules\/((?:@[^/]+\/)?[^/]+)/.exec(fileForTag);
+    const nodeModuleName = nodeModuleMatch && nodeModuleMatch[1];
+    const isCoreTag = nodeModuleName === "marko";
+    const documentation = {
+      kind: import_vscode_languageserver6.MarkupKind.Markdown,
+      value: it.html ? `Built in [<${it.name}>](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/${it.name}) HTML tag.` : nodeModuleName ? isCoreTag ? `Core Marko [<${it.name}>](${fileURIForTag}) tag.` : `Custom Marko tag discovered from the ["${nodeModuleName}"](${fileURIForTag}) npm package.` : `Custom Marko tag discovered from:
+
+[${import_path2.default.relative(currentTemplateFilePath, fileForTag)}](${fileURIForTag})`
+    };
+    if (it.description) {
+      documentation.value += `
+
+${it.description}`;
+    }
+    const autocomplete = it.autocomplete && it.autocomplete[0];
+    if (autocomplete) {
+      if (autocomplete.displayText) {
+        label = autocomplete.displayText;
+      }
+      if (autocomplete.description) {
+        documentation.value += `
+
+${autocomplete.description}`;
+      }
+      if (autocomplete.descriptionMoreURL) {
+        documentation.value += `
+
+[More Info](${autocomplete.descriptionMoreURL})`;
+      }
+    }
+    return {
+      label,
+      documentation,
+      kind: import_vscode_languageserver6.CompletionItemKind.Class,
+      insertTextFormat: import_vscode_languageserver6.InsertTextFormat.Snippet,
+      textEdit: import_vscode_languageserver6.TextEdit.replace(tagNameRange, autocomplete && autocomplete.snippet || label)
+    };
+  }), true);
+}
+
+// src/utils/completions/types/styleContent.ts
+var import_vscode_languageserver7 = require("vscode-languageserver");
+var import_vscode_languageserver_textdocument2 = require("vscode-languageserver-textdocument");
+var import_vscode_css_languageservice = require("vscode-css-languageservice");
+var services = {
+  css: import_vscode_css_languageservice.getCSSLanguageService,
+  scss: import_vscode_css_languageservice.getSCSSLanguageService,
+  less: import_vscode_css_languageservice.getLESSLanguageService
+};
+function styleContent(_taglib, document, params, event) {
+  const service = services[event.language]();
+  const startPos = document.positionAt(event.pos);
+  const relativePos = shiftPosition(params.position, import_vscode_languageserver7.Position.create(startPos.line * -1, startPos.character * -1));
+  const contentDocument = import_vscode_languageserver_textdocument2.TextDocument.create(document.uri, event.language, document.version, event.content);
+  const completions = service.doComplete(contentDocument, relativePos, service.parseStylesheet(contentDocument));
+  return shiftCompletionRanges(completions, startPos);
+}
+
+// src/utils/definitions/index.ts
+var definitions_exports = {};
+__export(definitions_exports, {
+  attributeName: () => attributeName2,
+  openTagName: () => openTagName2
+});
+
+// src/utils/definitions/types/attributeName.ts
+var import_vscode_uri4 = require("vscode-uri");
+var import_vscode_languageserver8 = require("vscode-languageserver");
+
+// src/utils/regexp-builder.ts
+function RegExpBuilder(strings, ...expressions) {
+  let i = 0;
+  let src = strings[0].slice(strings[0].indexOf("/") + 1);
+  const secondLastExprIndex = strings.length - 2;
+  for (; i < secondLastExprIndex; i++) {
+    src += escape(expressions[i]) + strings[i + 1];
+  }
+  src += escape(expressions[i]);
+  const lastStr = strings[i + 1];
+  const lastSlashIndex = lastStr.lastIndexOf("/");
+  let flags = "";
+  if (lastSlashIndex === -1) {
+    src += lastStr;
+  } else {
+    flags = lastStr.slice(lastSlashIndex + 1);
+    src += lastStr.slice(0, lastSlashIndex);
+  }
+  return new RegExp(src, flags);
+}
+function escape(val) {
+  return String(val).replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+
+// src/utils/definitions/types/attributeName.ts
+function attributeName2(taglib, document, _params, event) {
+  const tagName = event.tag.tagNameExpression ? void 0 : event.tag.tagName;
+  const tagDef = tagName && taglib.getTag(tagName);
+  const attrDef = taglib.getAttribute(tagName || "*", event.name);
+  let range = START_OF_FILE;
+  if (!attrDef) {
+    return;
+  }
+  const attrEntryFile = attrDef.filePath || tagDef && tagDef.filePath;
+  if (!attrEntryFile) {
+    return;
+  }
+  if (/\/marko(?:-tag)?\.json$/.test(attrEntryFile)) {
+    const tagDefDoc = createTextDocument(attrEntryFile);
+    const match = RegExpBuilder`/"@${event.name}"\s*:\s*[^\r\n,]+/g`.exec(tagDefDoc.getText());
+    if (match && match.index) {
+      range = import_vscode_languageserver8.Range.create(tagDefDoc.positionAt(match.index), tagDefDoc.positionAt(match.index + match[0].length));
+    }
+  }
+  return [
+    import_vscode_languageserver8.LocationLink.create(import_vscode_uri4.URI.file(attrEntryFile).toString(), range, range, rangeFromEvent(document, event))
+  ];
+}
+
+// src/utils/definitions/types/openTagName.ts
+var import_vscode_uri5 = require("vscode-uri");
+var import_vscode_languageserver9 = require("vscode-languageserver");
+function openTagName2(taglib, document, _params, event) {
+  let tagDef;
+  let range = START_OF_FILE;
+  const isAttributeTag = event.tagName[0] === "@";
+  if (isAttributeTag) {
+    const parentTag = findNonControlFlowParent(event);
+    tagDef = parentTag && (parentTag.tagNameExpression ? void 0 : taglib.getTag(parentTag.tagName));
+  } else {
+    tagDef = taglib.getTag(event.tagName);
+  }
+  if (!tagDef) {
+    return;
+  }
+  const tagEntryFile = tagDef.template || tagDef.renderer || tagDef.filePath;
+  if (/\/marko(?:-tag)?\.json$/.test(tagEntryFile)) {
+    const tagDefDoc = createTextDocument(tagEntryFile);
+    const match = RegExpBuilder`/"<${event.tagName}>"\s*:\s*[^\r\n,]+/g`.exec(tagDefDoc.getText());
+    if (match && match.index) {
+      range = import_vscode_languageserver9.Range.create(tagDefDoc.positionAt(match.index), tagDefDoc.positionAt(match.index + match[0].length));
+    }
+  }
+  return [
+    import_vscode_languageserver9.LocationLink.create(import_vscode_uri5.URI.file(tagEntryFile).toString(), range, range, rangeFromEvent(document, event))
+  ];
+}
+
+// src/index.ts
+if (typeof require !== "undefined" && require.extensions && !(".ts" in require.extensions)) {
+  require.extensions[".ts"] = void 0;
+}
+var cacheForCompiler = /* @__PURE__ */ new WeakMap();
+var connection = (0, import_node.createConnection)(import_node.ProposedFeatures.all);
+var prevDiagnostics = /* @__PURE__ */ new WeakMap();
+var diagnosticTimeouts = /* @__PURE__ */ new WeakMap();
+var documents = new import_node.TextDocuments(import_vscode_languageserver_textdocument3.TextDocument);
+var markoErrorRegExp = /^(.+?)(?:\((\d+)(?:\s*,\s*(\d+))?\))?: (.*)$/gm;
 console.log = (...args) => {
-    connection.console.log(args.join(" "));
+  connection.console.log(args.map((v) => (0, import_util.inspect)(v)).join(" "));
 };
 console.error = (...args) => {
-    connection.console.error(args.map((arg) => arg.stack || arg).join("\n"));
+  connection.console.error(args.map((v) => (0, import_util.inspect)(v)).join(" "));
 };
 process.on("uncaughtException", console.error);
 process.on("unhandledRejection", console.error);
 connection.onInitialize(() => {
-    return {
-        capabilities: {
-            textDocumentSync: node_1.TextDocumentSyncKind.Incremental,
-            documentFormattingProvider: true,
-            definitionProvider: true,
-            completionProvider: {
-                triggerCharacters: [".", ":", "<", ">", "@", "/"],
-            },
-        },
-    };
+  return {
+    capabilities: {
+      textDocumentSync: import_node.TextDocumentSyncKind.Incremental,
+      documentFormattingProvider: true,
+      definitionProvider: true,
+      completionProvider: {
+        triggerCharacters: [".", ":", "<", ">", "@", "/"]
+      }
+    }
+  };
 });
 connection.onInitialized(() => {
-    documents.all().forEach((doc) => queueValidation(doc));
+  documents.all().forEach((doc) => queueValidation(doc));
 });
 connection.onCompletion((params) => {
-    const doc = documents.get(params.textDocument.uri);
-    const taglib = (0, compiler_1.getTagLibLookup)(doc);
-    if (!taglib)
-        return node_1.CompletionList.create([], true);
-    const event = (0, htmljs_parser_1.parseUntilOffset)({
-        taglib,
-        offset: doc.offsetAt(params.position),
-        text: doc.getText(),
-    });
-    const handler = event && completionTypes[event.type];
-    return ((handler && handler(taglib, doc, params, event)) ||
-        node_1.CompletionList.create([], true));
+  const doc = documents.get(params.textDocument.uri);
+  const taglib = getTagLibLookup(doc);
+  if (!taglib)
+    return import_node.CompletionList.create([], true);
+  const event = parseUntilOffset({
+    taglib,
+    offset: doc.offsetAt(params.position),
+    text: doc.getText()
+  });
+  const handler = event && completions_exports[event.type];
+  return handler && handler(taglib, doc, params, event) || import_node.CompletionList.create([], true);
 });
 connection.onDefinition((params) => {
-    const doc = documents.get(params.textDocument.uri);
-    const taglib = (0, compiler_1.getTagLibLookup)(doc);
-    if (!taglib)
-        return;
-    const event = (0, htmljs_parser_1.parseUntilOffset)({
-        taglib,
-        offset: doc.offsetAt(params.position),
-        text: doc.getText(),
-    });
-    const handler = event && definitionTypes[event.type];
-    return handler && handler(taglib, doc, params, event);
+  const doc = documents.get(params.textDocument.uri);
+  const taglib = getTagLibLookup(doc);
+  if (!taglib)
+    return;
+  const event = parseUntilOffset({
+    taglib,
+    offset: doc.offsetAt(params.position),
+    text: doc.getText()
+  });
+  const handler = event && definitions_exports[event.type];
+  return handler && handler(taglib, doc, params, event);
 });
-connection.onDocumentFormatting(async ({ textDocument, options, }) => {
-    try {
-        const doc = documents.get(textDocument.uri);
-        const { fsPath, scheme } = vscode_uri_1.URI.parse(textDocument.uri);
-        const text = doc.getText();
-        const formatted = prettier.format(text, Object.assign({ parser: "marko", filepath: fsPath, tabWidth: options.tabSize, useTabs: options.insertSpaces === false }, (scheme === "file" ? await prettier
-            .resolveConfig(fsPath, {
-            editorconfig: true,
-        })
-            .catch(() => null) : null)));
-        return [
-            node_1.TextEdit.replace(node_1.Range.create(doc.positionAt(0), doc.positionAt(text.length)), formatted),
-        ];
-    }
-    catch (e) {
-        displayMessage("Error", (0, util_1.inspect)(e, { colors: false }));
-    }
+connection.onDocumentFormatting(async ({
+  textDocument,
+  options
+}) => {
+  try {
+    const doc = documents.get(textDocument.uri);
+    const { fsPath, scheme } = import_vscode_uri6.URI.parse(textDocument.uri);
+    const text = doc.getText();
+    const formatted = prettier.format(text, __spreadValues({
+      parser: "marko",
+      filepath: fsPath,
+      plugins: [markoPrettier],
+      tabWidth: options.tabSize,
+      useTabs: options.insertSpaces === false
+    }, scheme === "file" ? await prettier.resolveConfig(fsPath, {
+      editorconfig: true
+    }).catch(() => null) : null));
     return [
-        node_1.TextEdit.replace(node_1.Range.create(node_1.Position.create(0, 0), node_1.Position.create(0, 0)), ""),
+      import_node.TextEdit.replace(import_node.Range.create(doc.positionAt(0), doc.positionAt(text.length)), formatted)
     ];
+  } catch (e) {
+    displayMessage("Error", (0, import_util.inspect)(e, { colors: false }));
+  }
+  return [
+    import_node.TextEdit.replace(import_node.Range.create(import_node.Position.create(0, 0), import_node.Position.create(0, 0)), "")
+  ];
 });
 connection.onDidChangeWatchedFiles(() => {
-    const clearedCompilers = new Set();
-    for (const doc of documents.all()) {
-        const compiler = (0, compiler_1.getCompilerForDoc)(doc);
-        if (!clearedCompilers.has(compiler)) {
-            clearCaches(compiler);
-            clearedCompilers.add(compiler);
-        }
+  const clearedCompilers = /* @__PURE__ */ new Set();
+  for (const doc of documents.all()) {
+    const { compiler } = getCompilerAndTranslatorForDoc(doc);
+    if (!clearedCompilers.has(compiler)) {
+      clearCaches(compiler);
+      clearedCompilers.add(compiler);
     }
+  }
 });
 documents.onDidChangeContent((change) => {
-    queueValidation(change.document);
-    if (change.document.version > 1) {
-        clearCaches((0, compiler_1.getCompilerForDoc)(change.document));
-    }
+  queueValidation(change.document);
+  if (change.document.version > 1) {
+    clearCaches(getCompilerAndTranslatorForDoc(change.document).compiler);
+  }
 });
 function queueValidation(doc) {
-    clearTimeout(diagnosticTimeouts.get(doc));
-    diagnosticTimeouts.set(doc, setTimeout(() => {
-        const prevDiag = prevDiagnostics.get(doc);
-        const nextDiag = doValidate(doc);
-        if (prevDiag && (0, util_1.isDeepStrictEqual)(prevDiag, nextDiag)) {
-            return;
-        }
-        prevDiagnostics.set(doc, nextDiag);
-        connection.sendDiagnostics({
-            uri: doc.uri,
-            diagnostics: nextDiag,
-        });
-    }, 800));
+  clearTimeout(diagnosticTimeouts.get(doc));
+  diagnosticTimeouts.set(doc, setTimeout(() => {
+    const prevDiag = prevDiagnostics.get(doc);
+    const nextDiag = doValidate(doc);
+    if (prevDiag && (0, import_util.isDeepStrictEqual)(prevDiag, nextDiag)) {
+      return;
+    }
+    prevDiagnostics.set(doc, nextDiag);
+    connection.sendDiagnostics({
+      uri: doc.uri,
+      diagnostics: nextDiag
+    });
+  }, 800));
 }
 function doValidate(doc) {
-    const { fsPath, scheme } = vscode_uri_1.URI.parse(doc.uri);
-    if (scheme !== "file") {
-        return [];
-    }
-    const compiler = (0, compiler_1.getCompilerForDoc)(doc);
-    const diagnostics = [];
-    try {
-        compiler.compileSync(doc.getText(), fsPath, {
-            cache: getCacheForCompiler(compiler),
-            output: "source",
-            code: false,
-        });
-    }
-    catch (e) {
-        let match;
-        while ((match = markoErrorRegExp.exec(e.message))) {
-            const [, fileName, rawLine, rawCol, msg] = match;
-            const line = (parseInt(rawLine, 10) || 1) - 1;
-            const col = (parseInt(rawCol, 10) || 1) - 1;
-            diagnostics.push(node_1.Diagnostic.create(node_1.Range.create(line, col, line, col), msg, node_1.DiagnosticSeverity.Error, undefined, fileName));
-        }
+  const { fsPath, scheme } = import_vscode_uri6.URI.parse(doc.uri);
+  if (scheme !== "file") {
+    return [];
+  }
+  const { compiler, translator } = getCompilerAndTranslatorForDoc(doc);
+  const diagnostics = [];
+  try {
+    compiler.compileSync(doc.getText(), fsPath, {
+      cache: getCacheForCompiler(compiler),
+      output: "source",
+      code: false,
+      translator
+    });
+  } catch (e) {
+    let match;
+    while (match = markoErrorRegExp.exec(e.message)) {
+      const [, fileName, rawLine, rawCol, msg] = match;
+      const line = (parseInt(rawLine, 10) || 1) - 1;
+      const col = (parseInt(rawCol, 10) || 1) - 1;
+      diagnostics.push(import_node.Diagnostic.create(import_node.Range.create(line, col, line, col), msg, import_node.DiagnosticSeverity.Error, void 0, fileName));
     }
-    return diagnostics;
+  }
+  return diagnostics;
 }
 function clearCaches(compiler) {
-    var _a;
-    (_a = cacheForCompiler.get(compiler)) === null || _a === void 0 ? void 0 : _a.clear();
-    compiler.taglib.clearCaches();
+  var _a;
+  (_a = cacheForCompiler.get(compiler)) == null ? void 0 : _a.clear();
+  compiler.taglib.clearCaches();
 }
 function getCacheForCompiler(compiler) {
-    let cache = cacheForCompiler.get(compiler);
-    if (!cache) {
-        cacheForCompiler.set(compiler, (cache = new Map()));
-    }
-    return cache;
+  let cache = cacheForCompiler.get(compiler);
+  if (!cache) {
+    cacheForCompiler.set(compiler, cache = /* @__PURE__ */ new Map());
+  }
+  return cache;
 }
 function displayMessage(type, msg) {
-    setImmediate(() => {
-        connection.sendNotification(`show${type}`, msg);
-    });
+  setImmediate(() => {
+    connection.sendNotification(`show${type}`, msg);
+  });
 }
 documents.listen(connection);
 connection.listen();
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map