@marko/language-server 0.12.3 → 0.12.6

package/dist/index.js

@@ -1,27 +1,10 @@
+"use strict";
 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))
@@ -34,315 +17,780 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // 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");
+var import_util2 = require("util");
 
 // src/utils/compiler.ts
-var import_path = __toESM(require("path"));
-var import_vscode_uri = require("vscode-uri");
+var import_vscode_uri2 = 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)));
+
+// src/utils/doc-file.ts
+var import_path = __toESM(require("path"));
+var import_vscode_uri = require("vscode-uri");
+function getDocDir(doc) {
+  const filename = getDocFile(doc);
+  return filename ? import_path.default.dirname(filename) : void 0;
+}
+function getDocFile(doc) {
+  return import_vscode_uri.URI.parse(doc.uri).fsPath;
+}
+
+// src/utils/parser.ts
+var import_htmljs_parser = require("htmljs-parser");
+
+// src/utils/get-node-at-offset.ts
+function getNodeAtOffset(offset, program) {
+  const bodyNode = childAtOffset(offset, program.body);
+  if (bodyNode)
+    return visitChildNode(offset, bodyNode);
+  return childAtOffset(offset, program.static) || program;
+}
+function visitChildNode(offset, child) {
+  switch (child.type) {
+    case 1 /* Tag */:
+    case 14 /* AttrTag */:
+      return visitTag(offset, child);
+    default:
+      return child;
   }
-  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 visitTag(offset, tag) {
+  const { body } = tag;
+  if (body && offset > tag.open.end) {
+    const childNode = childAtOffset(offset, body);
+    return childNode ? visitChildNode(offset, childNode) : tag;
+  }
+  const { attrs } = tag;
+  if (attrs && offset > attrs[0].start) {
+    const attrNode = childAtOffset(offset, attrs);
+    return attrNode ? visitAttrNode(offset, attrNode) : tag;
+  }
+  const { var: tagVar } = tag;
+  if (tagVar && offset > tagVar.start && offset <= tagVar.end) {
+    return tagVar;
+  }
+  const { args } = tag;
+  if (args && offset > args.start && offset <= args.end) {
+    return args;
   }
+  const { params } = tag;
+  if (params && offset > params.start && offset <= params.end) {
+    return params;
+  }
+  const { name } = tag;
+  if (name && offset <= name.end) {
+    return name;
+  }
+  return tag;
 }
-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;
+function visitAttrNode(offset, attr) {
+  switch (attr.type) {
+    case 14 /* AttrTag */:
+      return visitTag(offset, attr);
+    case 8 /* AttrNamed */: {
+      const { value } = attr;
+      if (value && offset > value.start) {
+        return value;
       }
-      require((0, import_resolve_from.default)(dir, translator));
-      return {
-        compiler: require((0, import_resolve_from.default)(dir, "@marko/compiler")),
-        translator
-      };
-    } catch {
+      const { name } = attr;
+      if (offset > name.start && offset <= name.end) {
+        return name;
+      }
+      break;
     }
   }
-  return {
-    compiler: builtinCompiler,
-    translator: builtinTranslator
-  };
+  return attr;
+}
+function childAtOffset(offset, children) {
+  let max = children.length - 1;
+  if (max === -1)
+    return void 0;
+  let min = 0;
+  while (min < max) {
+    const mid = 1 + min + max >>> 1;
+    if (children[mid].start < offset) {
+      min = mid;
+    } else {
+      max = mid - 1;
+    }
+  }
+  const child = children[min];
+  return offset > child.start && offset <= child.end ? child : void 0;
 }
 
-// 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;
+// src/utils/parser.ts
+var UNFINISHED = Number.MAX_SAFE_INTEGER;
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2[NodeType2["Program"] = 0] = "Program";
+  NodeType2[NodeType2["Tag"] = 1] = "Tag";
+  NodeType2[NodeType2["OpenTagName"] = 2] = "OpenTagName";
+  NodeType2[NodeType2["ShorthandId"] = 3] = "ShorthandId";
+  NodeType2[NodeType2["ShorthandClassName"] = 4] = "ShorthandClassName";
+  NodeType2[NodeType2["TagVar"] = 5] = "TagVar";
+  NodeType2[NodeType2["TagArgs"] = 6] = "TagArgs";
+  NodeType2[NodeType2["TagParams"] = 7] = "TagParams";
+  NodeType2[NodeType2["AttrNamed"] = 8] = "AttrNamed";
+  NodeType2[NodeType2["AttrName"] = 9] = "AttrName";
+  NodeType2[NodeType2["AttrArgs"] = 10] = "AttrArgs";
+  NodeType2[NodeType2["AttrValue"] = 11] = "AttrValue";
+  NodeType2[NodeType2["AttrMethod"] = 12] = "AttrMethod";
+  NodeType2[NodeType2["AttrSpread"] = 13] = "AttrSpread";
+  NodeType2[NodeType2["AttrTag"] = 14] = "AttrTag";
+  NodeType2[NodeType2["Text"] = 15] = "Text";
+  NodeType2[NodeType2["CDATA"] = 16] = "CDATA";
+  NodeType2[NodeType2["Doctype"] = 17] = "Doctype";
+  NodeType2[NodeType2["Declaration"] = 18] = "Declaration";
+  NodeType2[NodeType2["Comment"] = 19] = "Comment";
+  NodeType2[NodeType2["Statement"] = 20] = "Statement";
+  NodeType2[NodeType2["Placeholder"] = 21] = "Placeholder";
+  NodeType2[NodeType2["Scriptlet"] = 22] = "Scriptlet";
+  return NodeType2;
+})(NodeType || {});
+function parse(source) {
+  const program = {
+    type: 0 /* Program */,
+    parent: void 0,
+    static: [],
+    body: [],
+    start: 0,
+    end: source.length
+  };
+  let curBodyType;
+  let curOpenTagStart;
+  let curParent = program;
+  let curAttr = void 0;
+  let curBody = program.body;
   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);
+    onText(range) {
+      curBody.push({
+        type: 15 /* Text */,
+        parent: curParent,
+        start: range.start,
+        end: range.end
+      });
     },
-    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;
-        }
+    onCDATA(range) {
+      curBody.push({
+        type: 16 /* CDATA */,
+        parent: curParent,
+        value: range.value,
+        start: range.start,
+        end: range.end
+      });
+    },
+    onDoctype(range) {
+      curBody.push({
+        type: 17 /* Doctype */,
+        parent: curParent,
+        value: range.value,
+        start: range.start,
+        end: range.end
+      });
+    },
+    onDeclaration(range) {
+      curBody.push({
+        type: 18 /* Declaration */,
+        parent: curParent,
+        value: range.value,
+        start: range.start,
+        end: range.end
+      });
+    },
+    onComment(range) {
+      curBody.push({
+        type: 19 /* Comment */,
+        parent: curParent,
+        value: range.value,
+        start: range.start,
+        end: range.end
+      });
+    },
+    onPlaceholder(range) {
+      curBody.push({
+        type: 21 /* Placeholder */,
+        parent: curParent,
+        value: range.value,
+        escape: range.escape,
+        start: range.start,
+        end: range.end
+      });
+    },
+    onScriptlet(range) {
+      curBody.push({
+        type: 22 /* Scriptlet */,
+        parent: curParent,
+        value: range.value,
+        block: range.block,
+        start: range.start,
+        end: range.end
+      });
+    },
+    onOpenTagStart(range) {
+      curOpenTagStart = range;
+    },
+    onOpenTagName(range) {
+      let concise = true;
+      let start = range.start;
+      let type = 1 /* Tag */;
+      let nameText = void 0;
+      if (curOpenTagStart) {
+        concise = false;
+        start = curOpenTagStart.start;
+        curOpenTagStart = void 0;
       }
-      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
-          })) {
+      if (range.expressions.length) {
+        curBodyType = import_htmljs_parser.TagType.html;
+      } else {
+        switch (nameText = parser.read(range)) {
+          case "area":
+          case "base":
+          case "br":
+          case "col":
+          case "embed":
+          case "hr":
+          case "img":
+          case "input":
+          case "link":
+          case "meta":
+          case "param":
+          case "source":
+          case "track":
+          case "wbr":
+            curBodyType = import_htmljs_parser.TagType.void;
+            break;
+          case "html-comment":
+          case "script":
+          case "style":
+          case "textarea":
+            curBodyType = import_htmljs_parser.TagType.text;
             break;
+          case "class":
+          case "export":
+          case "import":
+          case "static": {
+            let i = program.body.length;
+            for (; i--; ) {
+              const prev = program.body[i];
+              if (prev.type === 19 /* Comment */) {
+                program.static.push(prev);
+              } else {
+                break;
+              }
+            }
+            program.body.length = i + 1;
+            program.static.push(curParent = {
+              type: 20 /* Statement */,
+              parent: program,
+              start: range.start,
+              end: UNFINISHED
+            });
+            return curBodyType = import_htmljs_parser.TagType.statement;
           }
-        } else {
-          attrEndPos = attr.argument ? attr.argument.endPos + 1 : attr.endPos;
+          default:
+            if (nameText[0] === "@") {
+              type = 14 /* AttrTag */;
+            }
+            curBodyType = import_htmljs_parser.TagType.html;
+            break;
         }
       }
-      finish(ev);
+      const parent = curParent;
+      const end = UNFINISHED;
+      const name = {
+        type: 2 /* OpenTagName */,
+        parent: void 0,
+        quasis: range.quasis,
+        expressions: range.expressions,
+        start: range.start,
+        end: range.end
+      };
+      const tag = curParent = name.parent = {
+        type,
+        parent,
+        owner: void 0,
+        concise,
+        open: { start, end },
+        nameText,
+        name,
+        var: void 0,
+        args: void 0,
+        params: void 0,
+        shorthandId: void 0,
+        shorthandClassNames: void 0,
+        attrs: void 0,
+        selfClosed: false,
+        bodyType: curBodyType,
+        body: void 0,
+        close: void 0,
+        start,
+        end
+      };
+      if (tag.type === 14 /* AttrTag */) {
+        let owner = parent;
+        outer:
+          do {
+            switch (owner.type) {
+              case 14 /* AttrTag */:
+                break;
+              case 1 /* Tag */:
+                if (isTransparentTag(owner)) {
+                  owner = owner.parent;
+                  continue outer;
+                }
+                break;
+              default:
+                break outer;
+            }
+            tag.owner = owner;
+            tag.nameText = resolveAttrTagName(tag);
+            pushAttr(owner, tag);
+          } while (false);
+      }
+      curBody.push(tag);
+      curOpenTagStart = void 0;
+      return curBodyType;
     },
-    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;
+    onTagShorthandId(range) {
+      curParent.shorthandId = {
+        type: 3 /* ShorthandId */,
+        parent: curParent,
+        quasis: range.quasis,
+        expressions: range.expressions,
+        start: range.start,
+        end: range.end
+      };
+    },
+    onTagShorthandClass(range) {
+      const shorthandClassName = {
+        type: 4 /* ShorthandClassName */,
+        parent: curParent,
+        quasis: range.quasis,
+        expressions: range.expressions,
+        start: range.start,
+        end: range.end
+      };
+      if (curParent.shorthandClassNames) {
+        curParent.shorthandClassNames.push(shorthandClassName);
+      } else {
+        curParent.shorthandClassNames = [shorthandClassName];
+      }
+    },
+    onTagVar(range) {
+      curParent.var = {
+        type: 5 /* TagVar */,
+        parent: curParent,
+        value: range.value,
+        start: range.start,
+        end: range.end
+      };
+    },
+    onTagParams(range) {
+      curParent.params = {
+        type: 7 /* TagParams */,
+        parent: curParent,
+        value: range.value,
+        start: range.start,
+        end: range.end
+      };
+    },
+    onTagArgs(range) {
+      curParent.args = {
+        type: 6 /* TagArgs */,
+        parent: curParent,
+        value: range.value,
+        start: range.start,
+        end: range.end
+      };
+    },
+    onAttrName(range) {
+      const parent = curParent;
+      const name = {
+        type: 9 /* AttrName */,
+        parent: void 0,
+        start: range.start,
+        end: range.end
+      };
+      pushAttr(parent, curAttr = name.parent = {
+        type: 8 /* AttrNamed */,
+        parent,
+        name,
+        value: void 0,
+        args: void 0,
+        start: range.start,
+        end: range.end
+      });
+    },
+    onAttrArgs(range) {
+      curAttr.args = {
+        type: 10 /* AttrArgs */,
+        parent: curAttr,
+        value: range.value,
+        start: range.start,
+        end: range.end
+      };
+    },
+    onAttrValue(range) {
+      curAttr.value = {
+        type: 11 /* AttrValue */,
+        parent: curAttr,
+        value: range.value,
+        bound: range.bound,
+        start: range.start,
+        end: range.end
+      };
+      curAttr.end = range.end;
+    },
+    onAttrMethod(range) {
+      curAttr.value = {
+        type: 12 /* AttrMethod */,
+        parent: curAttr,
+        params: range.params,
+        body: range.body,
+        start: range.start,
+        end: range.end
+      };
+      curAttr.end = range.end;
+    },
+    onAttrSpread(range) {
+      pushAttr(curParent, {
+        type: 13 /* AttrSpread */,
+        parent: curParent,
+        value: range.value,
+        start: range.start,
+        end: range.end
+      });
+    },
+    onOpenTagEnd(range) {
+      curAttr = void 0;
+      if (curBodyType === import_htmljs_parser.TagType.statement) {
+        curParent.end = range.end;
+        curParent = curParent.parent;
+      } else {
+        const tag = curParent;
+        tag.open.end = range.end;
+        if (range.selfClosed || curBodyType === import_htmljs_parser.TagType.void) {
+          curParent = tag.parent;
+          tag.selfClosed = range.selfClosed;
+          tag.end = range.end;
+        } else {
+          curBody = tag.body = [];
         }
       }
-      finish(ev);
     },
-    onCloseTag(ev) {
-      parentTag = parentTag && parentTag.parent;
-      finish(ev);
-    }
-  }, {
-    isOpenTagOnly(ev) {
-      const tagDef = taglib.getTag(ev);
-      return tagDef && tagDef.openTagOnly;
+    onCloseTagStart(range) {
+      curParent.close = {
+        start: range.start,
+        end: Number.MAX_SAFE_INTEGER
+      };
+    },
+    onCloseTagEnd(range) {
+      if (hasCloseTag(curParent))
+        curParent.close.end = range.end;
+      curParent.end = range.end;
+      curBody = (curParent = curParent.parent).body;
     }
   });
-  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"
+  parser.parse(source);
+  return {
+    read: parser.read,
+    locationAt: parser.locationAt,
+    positionAt: parser.positionAt,
+    nodeAt: (offset) => getNodeAtOffset(offset, program),
+    program
+  };
+}
+function pushAttr(parent, node) {
+  if (parent.attrs) {
+    parent.attrs.push(node);
+  } else {
+    parent.attrs = [node];
+  }
+}
+function hasCloseTag(parent) {
+  return parent.close !== void 0;
+}
+function resolveAttrTagName(tag) {
+  let name = tag.nameText;
+  let parentTag = tag.owner;
+  do {
+    switch (parentTag.type) {
+      case 1 /* Tag */:
+        return parentTag.nameText ? `${parentTag.nameText}:${name}` : void 0;
+      case 14 /* AttrTag */:
+        name = `${parentTag.nameText}:${name}`;
+        parentTag = parentTag.owner;
+        break;
+      default:
+        return;
     }
-  ], true);
+  } while (parentTag);
+}
+function isTransparentTag(node) {
+  return node.nameText !== void 0 && /^(?:if|else(?:-if)?|for|while)$/.test(node.nameText);
 }
 
-// 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;
+// src/utils/compiler.ts
+var lookupKey = Symbol("lookup");
+var compilerInfoByDir = /* @__PURE__ */ new Map();
+var builtinInfo = {
+  cache: /* @__PURE__ */ new Map(),
+  lookup: builtinCompiler.taglib.buildLookup(__dirname, builtinTranslator),
+  compiler: builtinCompiler,
+  translator: builtinTranslator
+};
+builtinCompiler.configure({ translator: builtinTranslator });
+function parse2(doc) {
+  const compilerInfo = getCompilerInfo(doc);
+  let parsed = compilerInfo.cache.get(doc);
+  if (!parsed) {
+    const source = doc.getText();
+    compilerInfo.cache.set(doc, parsed = parse(source));
   }
-  return null;
+  return parsed;
 }
-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 getCompilerInfo(doc) {
+  const dir = getDocDir(doc);
+  if (!dir)
+    return builtinInfo;
+  let info = compilerInfoByDir.get(dir);
+  if (!info) {
+    info = loadCompilerInfo(dir);
+    compilerInfoByDir.set(dir, info);
+  }
+  return info;
 }
-function shiftCompletionRanges(list, offset) {
-  list.items.forEach((item) => {
-    if (item.additionalTextEdits) {
-      item.additionalTextEdits.forEach((edit) => shiftRange(edit.range, offset));
+function setup(connection3, documents2) {
+  connection3.onDidChangeWatchedFiles(() => {
+    clearAllCaches();
+  });
+  documents2.onDidChangeContent(({ document }) => {
+    if (document.version > 1) {
+      if (document.languageId === "marko") {
+        getCompilerInfo(document).cache.delete(document);
+      } else if (/[./\\]marko(?:-tag)?\.json$/.test(document.uri)) {
+        clearAllCaches();
+      }
     }
-    if (item.textEdit) {
-      shiftEdit(item.textEdit, offset);
+  });
+  documents2.onDidClose(({ document }) => {
+    if (document.languageId === "marko" && import_vscode_uri2.URI.parse(document.uri).scheme !== "file") {
+      getCompilerInfo(document).cache.delete(document);
     }
   });
-  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 clearAllCaches() {
+  for (const [, info] of compilerInfoByDir) {
+    info.cache.clear();
+    info.compiler.taglib.clearCaches();
   }
 }
-function shiftRange(range, offset) {
-  if (range) {
-    shiftPosition(range.start, offset);
-    shiftPosition(range.end, offset);
+function loadCompilerInfo(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);
+  const cache2 = /* @__PURE__ */ new Map();
+  let translator = builtinTranslator;
+  let compiler = builtinCompiler;
+  if (pkg && /^5\./.test(pkg.version)) {
+    try {
+      let checkTranslator = [].concat(Object.keys(pkg.dependencies), Object.keys(pkg.peerDependencies), Object.keys(pkg.devDependencies)).find((name) => /^marko$|^(@\/marko\/|marko-)translator-/.test(name));
+      if (checkTranslator === "marko" || !checkTranslator) {
+        checkTranslator = require((0, import_resolve_from.default)(dir, "@marko/compiler/config")).translator;
+      }
+      [compiler, translator] = [
+        require((0, import_resolve_from.default)(dir, "@marko/compiler")),
+        require((0, import_resolve_from.default)(dir, checkTranslator))
+      ];
+    } catch {
+    }
   }
+  return {
+    cache: cache2,
+    get lookup() {
+      let lookup = cache2.get(lookupKey);
+      if (lookup === void 0) {
+        try {
+          lookup = compiler.taglib.buildLookup(dir, translator);
+        } catch {
+          lookup = builtinInfo.lookup;
+        }
+        cache2.set(lookupKey, lookup);
+      }
+      return lookup;
+    },
+    compiler,
+    translator
+  };
+}
+
+// src/utils/messages.ts
+var import_util = require("util");
+var connection;
+function setup2(_) {
+  connection = _;
+}
+function displayError(data) {
+  display("showError", data);
 }
-function shiftPosition(pos, offset) {
-  if (pos.line === 0) {
-    pos.character += offset.character;
+function display(type, data) {
+  const msg = typeof data === "string" ? data : (0, import_util.inspect)(data, { colors: false });
+  setImmediate(() => connection.sendNotification(type, msg));
+}
+
+// src/service/index.ts
+var import_vscode_languageserver11 = require("vscode-languageserver");
+
+// src/service/marko/complete/index.ts
+var import_vscode_languageserver4 = require("vscode-languageserver");
+
+// src/service/marko/complete/Tag.ts
+var import_vscode_languageserver = require("vscode-languageserver");
+var partialCloseTagReg = /<\/(?:[^><]*>)?/iy;
+function Tag(event) {
+  const { node } = event;
+  const isClosed = node.end !== UNFINISHED;
+  if (isClosed || node.concise)
+    return;
+  const { offset, parsed, code } = event;
+  const closingTagStr = `</${node.nameText}>`;
+  if (offset === node.open.end) {
+    return [
+      {
+        label: closingTagStr,
+        kind: import_vscode_languageserver.CompletionItemKind.Class,
+        insertTextFormat: import_vscode_languageserver.InsertTextFormat.Snippet,
+        insertText: `
+	$0
+${closingTagStr}`
+      }
+    ];
+  } else if (node.close && offset >= node.close.start) {
+    const start = node.close.start;
+    partialCloseTagReg.lastIndex = start;
+    const [{ length }] = partialCloseTagReg.exec(code);
+    const end = start + length;
+    return [
+      {
+        label: closingTagStr,
+        kind: import_vscode_languageserver.CompletionItemKind.Class,
+        insertTextFormat: import_vscode_languageserver.InsertTextFormat.Snippet,
+        textEdit: import_vscode_languageserver.TextEdit.replace(parsed.locationAt({
+          start,
+          end
+        }), closingTagStr)
+      }
+    ];
   }
-  pos.line += offset.line;
-  return pos;
 }
 
-// src/utils/completions/types/attributeName.ts
-function attributeName(taglib, document, _params, event) {
+// src/service/marko/complete/OpenTagName.ts
+var import_path2 = __toESM(require("path"));
+var import_vscode_uri3 = require("vscode-uri");
+var import_vscode_languageserver2 = require("vscode-languageserver");
+function OpenTagName({
+  document,
+  lookup,
+  parsed,
+  node
+}) {
+  const currentTemplateFilePath = getDocFile(document);
+  const tag = node.parent;
+  const tagNameLocation = parsed.locationAt(node);
+  let tags;
+  if (tag.type === 14 /* AttrTag */) {
+    let parentTag = tag.owner;
+    while ((parentTag == null ? void 0 : parentTag.type) === 14 /* AttrTag */)
+      parentTag = parentTag.owner;
+    const parentTagDef = parentTag && parentTag.nameText && lookup.getTag(parentTag.nameText);
+    tags = parentTagDef && parentTagDef.nestedTags && Object.values(parentTagDef.nestedTags) || [];
+  } else {
+    tags = lookup.getTagsSorted().filter((it) => !it.isNestedTag);
+  }
+  return 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_languageserver2.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:
+
+[${currentTemplateFilePath ? import_path2.default.relative(currentTemplateFilePath, fileForTag) : currentTemplateFilePath}](${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_languageserver2.CompletionItemKind.Class,
+      insertTextFormat: import_vscode_languageserver2.InsertTextFormat.Snippet,
+      textEdit: import_vscode_languageserver2.TextEdit.replace(tagNameLocation, autocomplete && autocomplete.snippet || label)
+    };
+  });
+}
+
+// src/service/marko/complete/AttrName.ts
+var import_vscode_languageserver3 = require("vscode-languageserver");
+function AttrName({
+  offset,
+  node,
+  parsed,
+  lookup
+}) {
+  let name = parsed.read(node);
+  if (name[0] === "{")
+    return;
+  const modifierIndex = name.indexOf(":");
+  const hasModifier = modifierIndex !== -1;
+  if (hasModifier) {
+    if (offset >= node.start + modifierIndex) {
+      return [
+        {
+          label: "scoped",
+          kind: import_vscode_languageserver3.CompletionItemKind.Keyword,
+          detail: "Use to prefix with a unique ID"
+        },
+        {
+          label: "no-update",
+          kind: import_vscode_languageserver3.CompletionItemKind.Keyword,
+          detail: "Use to skip future updates to this attribute"
+        }
+      ];
+    } else {
+      name = name.slice(0, modifierIndex);
+    }
+  }
   const completions = [];
-  const attrNameRange = rangeFromEvent(document, event);
-  const tagDef = !event.tag.tagNameExpression && taglib.getTag(event.tag.tagName);
-  const tagName = tagDef && tagDef.name || "*";
+  const attrNameLoc = parsed.locationAt(hasModifier ? {
+    start: node.start,
+    end: node.start + name.length
+  } : node);
+  const tagName = node.parent.parent.nameText || "";
+  const tagDef = tagName && lookup.getTag(tagName);
   const nestedTagAttrs = {};
   const neverAttrs = /* @__PURE__ */ new Set();
   if (tagDef && tagDef.nestedTags) {
@@ -351,12 +799,12 @@ function attributeName(taglib, document, _params, event) {
       nestedTagAttrs[nestedTagDef.targetProperty] = true;
     }
   }
-  taglib.forEachAttribute(tagName, (attr) => {
+  lookup.forEachAttribute(tagName, (attr) => {
     if (attr.type === "never") {
       neverAttrs.add(attr.name);
     }
   });
-  taglib.forEachAttribute(tagName, (attr, parent) => {
+  lookup.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;
     }
@@ -404,138 +852,64 @@ function attributeName(taglib, document, _params, event) {
       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)
+      textEdit: import_vscode_languageserver3.TextEdit.replace(attrNameLoc, snippet)
     });
   });
-  return import_vscode_languageserver3.CompletionList.create(completions, true);
+  return completions;
 }
 
-// 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/service/marko/complete/index.ts
+var handlers = {
+  Tag,
+  OpenTagName,
+  AttrName
+};
+var doComplete = async (doc, params) => {
+  var _a;
+  const parsed = parse2(doc);
+  const offset = doc.offsetAt(params.position);
+  const node = parsed.nodeAt(offset);
+  return import_vscode_languageserver4.CompletionList.create(await ((_a = handlers[NodeType[node.type]]) == null ? void 0 : _a.call(handlers, {
+    document: doc,
+    params,
+    parsed,
+    offset,
+    node,
+    code: doc.getText(),
+    ...getCompilerInfo(doc)
+  })) || [], true);
+};
 
-// src/utils/completions/types/openTag.ts
+// src/service/marko/validate.ts
 var import_vscode_languageserver5 = require("vscode-languageserver");
-function openTag(_taglib, doc, params, event) {
-  const triggerCharacter = params.context && params.context.triggerCharacter || doc.getText(import_vscode_languageserver5.Range.create(import_vscode_languageserver5.Position.create(params.position.line, params.position.character - 1), params.position));
-  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}`
+var markoErrorRegExp = /^(.+?)(?:\((\d+)(?:\s*,\s*(\d+))?\))?: (.*)$/gm;
+var doValidate = (doc) => {
+  const fsPath = getDocFile(doc);
+  const diagnostics = [];
+  const { compiler, translator, cache: cache2 } = getCompilerInfo(doc);
+  try {
+    compiler.compileSync(doc.getText(), fsPath || "untitled.marko", {
+      cache: cache2,
+      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_vscode_languageserver5.Diagnostic.create(import_vscode_languageserver5.Range.create(line, col, line, col), msg, import_vscode_languageserver5.DiagnosticSeverity.Error, void 0, fileName));
     }
-  ], 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
+  return diagnostics;
 };
-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/service/marko/definition/OpenTagName.ts
+var import_path3 = __toESM(require("path"));
+var import_vscode_uri5 = require("vscode-uri");
+var import_vscode_languageserver7 = require("vscode-languageserver");
 
 // src/utils/regexp-builder.ts
 function RegExpBuilder(strings, ...expressions) {
@@ -561,223 +935,612 @@ 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);
+// src/utils/utils.ts
+var import_fs = __toESM(require("fs"));
+var import_vscode_uri4 = require("vscode-uri");
+var import_vscode_languageserver6 = require("vscode-languageserver");
+var import_vscode_languageserver_textdocument = require("vscode-languageserver-textdocument");
+var START_OF_FILE = import_vscode_languageserver6.Range.create(import_vscode_languageserver6.Position.create(0, 0), import_vscode_languageserver6.Position.create(0, 0));
+function createTextDocument(filename) {
+  const uri = import_vscode_uri4.URI.file(filename).toString();
+  const content = import_fs.default.readFileSync(filename, "utf-8");
+  return import_vscode_languageserver_textdocument.TextDocument.create(uri, "plaintext", 0, content);
+}
+
+// src/service/marko/definition/OpenTagName.ts
+function OpenTagName2({
+  lookup,
+  parsed,
+  node
+}) {
+  const tag = node.parent;
+  let tagDef;
+  let range = START_OF_FILE;
+  if (tag.type === 14 /* AttrTag */) {
+    let parentTag = tag.owner;
+    while ((parentTag == null ? void 0 : parentTag.type) === 14 /* AttrTag */)
+      parentTag = parentTag.owner;
+    tagDef = parentTag && parentTag.nameText ? lookup.getTag(parentTag.nameText) : void 0;
+  } else {
+    tagDef = tag.nameText ? lookup.getTag(tag.nameText) : void 0;
+  }
+  if (!tagDef) {
+    return;
+  }
+  const tagEntryFile = tagDef.template || tagDef.renderer || tagDef.filePath;
+  if (!import_path3.default.isAbsolute(tagEntryFile)) {
+    return;
+  }
+  if (/\/marko(?:-tag)?\.json$/.test(tagEntryFile)) {
+    const tagDefDoc = createTextDocument(tagEntryFile);
+    const match = RegExpBuilder`/"(?:<${tag.nameText}>|${tag.nameText})"\s*:\s*[^\r\n,]+/g`.exec(tagDefDoc.getText());
+    if (match && match.index) {
+      range = import_vscode_languageserver7.Range.create(tagDefDoc.positionAt(match.index), tagDefDoc.positionAt(match.index + match[0].length));
+    }
+  }
+  return [
+    import_vscode_languageserver7.LocationLink.create(import_vscode_uri5.URI.file(tagEntryFile).toString(), range, range, parsed.locationAt(node))
+  ];
+}
+
+// src/service/marko/definition/AttrName.ts
+var import_vscode_uri6 = require("vscode-uri");
+var import_vscode_languageserver8 = require("vscode-languageserver");
+function AttrName2({
+  lookup,
+  parsed,
+  node
+}) {
+  const tagName = node.parent.parent.nameText;
+  const attrName = parsed.read(node);
+  if (attrName[0] === "{")
+    return;
+  const tagDef = tagName && lookup.getTag(tagName);
+  const attrDef = lookup.getAttribute(tagName || "", attrName);
   let range = START_OF_FILE;
   if (!attrDef) {
-    return [];
+    return;
   }
   const attrEntryFile = attrDef.filePath || tagDef && tagDef.filePath;
   if (!attrEntryFile) {
-    return [];
+    return;
   }
   if (/\/marko(?:-tag)?\.json$/.test(attrEntryFile)) {
     const tagDefDoc = createTextDocument(attrEntryFile);
-    const match = RegExpBuilder`/"@${event.name}"\s*:\s*[^\r\n,]+/g`.exec(tagDefDoc.getText());
+    const match = RegExpBuilder`/"@${attrName}"\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))
+    import_vscode_languageserver8.LocationLink.create(import_vscode_uri6.URI.file(attrEntryFile).toString(), range, range, parsed.locationAt(node))
   ];
 }
 
-// src/utils/definitions/types/openTagName.ts
-var import_path3 = __toESM(require("path"));
-var import_vscode_uri5 = require("vscode-uri");
+// src/service/marko/definition/index.ts
+var handlers2 = {
+  OpenTagName: OpenTagName2,
+  AttrName: AttrName2
+};
+var findDefinition = async (doc, params) => {
+  var _a;
+  const parsed = parse2(doc);
+  const offset = doc.offsetAt(params.position);
+  const node = parsed.nodeAt(offset);
+  return await ((_a = handlers2[NodeType[node.type]]) == null ? void 0 : _a.call(handlers2, {
+    document: doc,
+    params,
+    parsed,
+    offset,
+    node,
+    code: doc.getText(),
+    ...getCompilerInfo(doc)
+  })) || [];
+};
+
+// src/service/marko/format.ts
 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);
+var import_vscode_uri7 = require("vscode-uri");
+var prettier = __toESM(require("prettier"));
+var markoPrettier = __toESM(require("prettier-plugin-marko"));
+var NO_EDIT = [
+  import_vscode_languageserver9.TextEdit.replace(import_vscode_languageserver9.Range.create(import_vscode_languageserver9.Position.create(0, 0), import_vscode_languageserver9.Position.create(0, 0)), "")
+];
+var format2 = async (doc, params, token) => {
+  try {
+    const { fsPath, scheme } = import_vscode_uri7.URI.parse(doc.uri);
+    const text = doc.getText();
+    const options = {
+      parser: "marko",
+      filepath: fsPath,
+      plugins: [markoPrettier],
+      tabWidth: params.options.tabSize,
+      useTabs: params.options.insertSpaces === false,
+      ...scheme === "file" ? await prettier.resolveConfig(fsPath, {
+        editorconfig: true
+      }).catch(() => null) : null
+    };
+    if (!token.isCancellationRequested) {
+      return [
+        import_vscode_languageserver9.TextEdit.replace(import_vscode_languageserver9.Range.create(doc.positionAt(0), doc.positionAt(text.length)), prettier.format(text, options))
+      ];
+    }
+  } catch (e) {
+    displayError(e);
   }
-  if (!tagDef) {
-    return [];
+  return NO_EDIT;
+};
+
+// src/service/marko/index.ts
+var marko_default = {
+  doComplete,
+  doValidate,
+  findDefinition,
+  format: format2
+};
+
+// src/service/stylesheet/index.ts
+var import_vscode_languageserver10 = require("vscode-languageserver");
+var import_vscode_css_languageservice = require("vscode-css-languageservice");
+var import_vscode_languageserver_textdocument2 = require("vscode-languageserver-textdocument");
+
+// src/utils/extractor.ts
+function createExtractor(code) {
+  let generated = "";
+  const generatedMap = [];
+  return {
+    write(strs, ...exprs) {
+      const len = exprs.length;
+      for (let i = 0; i < len; i++) {
+        const expr = exprs[i];
+        generated += strs[i];
+        if (typeof expr === "string") {
+          generated += expr;
+        } else {
+          generatedMap.push(generated.length, expr.start, expr.end);
+          generated += code.slice(expr.start, expr.end);
+        }
+      }
+      generated += strs[len];
+    },
+    end() {
+      const sourceMap = generatedMap.slice();
+      (function sort(left, right) {
+        if (left < right) {
+          let next = left;
+          for (let i = left; i <= right; i += 3) {
+            if (sourceMap[i] <= sourceMap[right]) {
+              [sourceMap[next - 1], sourceMap[i - 1]] = [
+                sourceMap[i - 1],
+                sourceMap[next - 1]
+              ];
+              [sourceMap[next], sourceMap[i]] = [sourceMap[i], sourceMap[next]];
+              [sourceMap[next + 1], sourceMap[i + 1]] = [
+                sourceMap[i + 1],
+                sourceMap[next + 1]
+              ];
+              next += 3;
+            }
+          }
+          next -= 3;
+          sort(left, next - 3);
+          sort(next + 3, right);
+        }
+      })(1, sourceMap.length - 2);
+      return {
+        generated,
+        sourceOffsetAt(generatedOffset) {
+          let max = generatedMap.length / 3;
+          let min = 0;
+          while (min < max) {
+            const mid = 1 + min + max >>> 1;
+            if (generatedMap[mid * 3] <= generatedOffset) {
+              min = mid;
+            } else {
+              max = mid - 1;
+            }
+          }
+          const key = min * 3;
+          const generatedStart = generatedMap[key];
+          const sourceStart = generatedMap[key + 1];
+          const sourceEnd = generatedMap[key + 2];
+          return sourceEnd - sourceStart <= generatedOffset - generatedStart ? void 0 : sourceStart + (generatedOffset - generatedStart);
+        },
+        generatedOffsetAt(sourceOffset) {
+          let max = sourceMap.length / 3;
+          let min = 0;
+          while (min < max) {
+            const mid = 1 + min + max >>> 1;
+            if (sourceMap[mid * 3 + 1] <= sourceOffset) {
+              min = mid;
+            } else {
+              max = mid - 1;
+            }
+          }
+          const key = min * 3;
+          const sourceStart = sourceMap[key + 1];
+          const sourceEnd = sourceMap[key + 2];
+          if (sourceOffset < sourceStart || sourceOffset > sourceEnd)
+            return void 0;
+          const generatedStart = sourceMap[key];
+          return generatedStart + (sourceOffset - sourceStart);
+        }
+      };
+    }
+  };
+}
+
+// src/service/stylesheet/extract.ts
+function extractStyleSheets(code, program, lookup) {
+  let placeholderId = 0;
+  const extractorsByExt = {};
+  const read = (range) => code.slice(range.start, range.end);
+  const getExtractor = (ext) => extractorsByExt[ext] || (extractorsByExt[ext] = createExtractor(code));
+  const getFileExtFromTag = (tag) => {
+    const prefixEnd = tag.shorthandClassNames ? tag.shorthandClassNames.at(-1).end : tag.name.end;
+    return tag.shorthandClassNames ? read({
+      start: tag.shorthandClassNames[0].start,
+      end: prefixEnd
+    }).replace(/^.*\./, "") : "css";
+  };
+  const visit = (node) => {
+    var _a, _b, _c;
+    switch (node.type) {
+      case 1 /* Tag */:
+        if ((_a = node.body) == null ? void 0 : _a.length) {
+          if (node.nameText === "style") {
+            const ext = getFileExtFromTag(node);
+            for (const child of node.body) {
+              switch (child.type) {
+                case 15 /* Text */:
+                  getExtractor(ext).write`${child}`;
+                  break;
+                case 21 /* Placeholder */:
+                  getExtractor(ext).write`${`var(--_${placeholderId++})`}`;
+                  break;
+              }
+            }
+          } else {
+            if (node.attrs) {
+              for (const attr of node.attrs) {
+                if (attr.type === 8 /* AttrNamed */ && ((_b = attr.value) == null ? void 0 : _b.type) === 11 /* AttrValue */ && /^['"]$/.test(code[attr.value.value.start])) {
+                  const name = read(attr.name);
+                  if (name === "#style" || name === "style" && lookup && node.nameText && name === "style" && ((_c = lookup.getTag(node.nameText)) == null ? void 0 : _c.html)) {
+                    getExtractor("css").write`:root{${{
+                      start: attr.value.value.start + 1,
+                      end: attr.value.value.end - 1
+                    }}}`;
+                  }
+                }
+              }
+            }
+            for (const child of node.body) {
+              visit(child);
+            }
+          }
+        } else if (node.nameText === "style" && node.concise && node.attrs) {
+          const block = node.attrs.at(-1);
+          if (block.type === 8 /* AttrNamed */ && code[block.start] === "{") {
+            getExtractor(getFileExtFromTag(node)).write`${{
+              start: block.start + 1,
+              end: block.end - 1
+            }}`;
+          }
+        }
+        break;
+    }
+  };
+  for (const node of program.body)
+    visit(node);
+  const resultsByExt = {};
+  for (const ext in extractorsByExt) {
+    resultsByExt[ext] = extractorsByExt[ext].end();
   }
-  const tagEntryFile = tagDef.template || tagDef.renderer || tagDef.filePath;
-  if (!import_path3.default.isAbsolute(tagEntryFile)) {
-    return [];
+  return resultsByExt;
+}
+
+// src/service/stylesheet/index.ts
+var cache = /* @__PURE__ */ new WeakMap();
+var services = {
+  css: import_vscode_css_languageservice.getCSSLanguageService,
+  less: import_vscode_css_languageservice.getLESSLanguageService,
+  scss: import_vscode_css_languageservice.getSCSSLanguageService
+};
+var stylesheet_default = {
+  async doComplete(doc, params) {
+    const infoByExt = getStyleSheetInfo(doc);
+    const sourceOffset = doc.offsetAt(params.position);
+    for (const ext in infoByExt) {
+      const info = infoByExt[ext];
+      const generatedOffset = info.generatedOffsetAt(sourceOffset);
+      if (generatedOffset === void 0)
+        continue;
+      const { service: service2, virtualDoc } = info;
+      const result = service2.doComplete(virtualDoc, virtualDoc.positionAt(generatedOffset), info.parsed);
+      for (const item of result.items) {
+        if (item.additionalTextEdits) {
+          for (const edit of item.additionalTextEdits) {
+            if (!updateRange(doc, info, edit.range)) {
+              edit.newText = "";
+              edit.range = START_OF_FILE;
+            }
+          }
+        }
+        const { textEdit } = item;
+        if (textEdit) {
+          if (textEdit.range) {
+            if (!updateRange(doc, info, textEdit.range)) {
+              textEdit.newText = "";
+              textEdit.range = START_OF_FILE;
+            }
+          }
+          if (textEdit.insert) {
+            if (!updateRange(doc, info, textEdit.insert)) {
+              textEdit.newText = "";
+              textEdit.insert = START_OF_FILE;
+            }
+          }
+        }
+      }
+      return result;
+    }
+    return import_vscode_languageserver10.CompletionList.create([], true);
+  },
+  async findDefinition(doc, params) {
+    const infoByExt = getStyleSheetInfo(doc);
+    const sourceOffset = doc.offsetAt(params.position);
+    for (const ext in infoByExt) {
+      const info = infoByExt[ext];
+      const generatedOffset = info.generatedOffsetAt(sourceOffset);
+      if (generatedOffset === void 0)
+        continue;
+      const { service: service2, virtualDoc } = info;
+      const result = service2.findDefinition(virtualDoc, virtualDoc.positionAt(generatedOffset), info.parsed);
+      if (result && updateRange(doc, info, result.range)) {
+        return result;
+      }
+      break;
+    }
+  },
+  async doHover(doc, params) {
+    const infoByExt = getStyleSheetInfo(doc);
+    const sourceOffset = doc.offsetAt(params.position);
+    for (const ext in infoByExt) {
+      const info = infoByExt[ext];
+      const generatedOffset = info.generatedOffsetAt(sourceOffset);
+      if (generatedOffset === void 0)
+        continue;
+      const { service: service2, virtualDoc } = info;
+      const result = service2.doHover(virtualDoc, virtualDoc.positionAt(generatedOffset), service2.parseStylesheet(virtualDoc));
+      if (result && (!result.range || updateRange(doc, info, result.range))) {
+        return result;
+      }
+    }
+  },
+  async doValidate(doc) {
+    const infoByExt = getStyleSheetInfo(doc);
+    const result = [];
+    for (const ext in infoByExt) {
+      const info = infoByExt[ext];
+      for (const diag of info.service.doValidation(info.virtualDoc, info.parsed)) {
+        if (updateRange(doc, info, diag.range)) {
+          result.push(diag);
+        }
+      }
+    }
+    return result;
   }
-  if (/\/marko(?:-tag)?\.json$/.test(tagEntryFile)) {
-    const tagDefDoc = createTextDocument(tagEntryFile);
-    const match = RegExpBuilder`/"(?:<${event.tagName}>|${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));
+};
+function updateRange(doc, info, range) {
+  const start = info.sourceOffsetAt(info.virtualDoc.offsetAt(range.start));
+  const end = info.sourceOffsetAt(info.virtualDoc.offsetAt(range.end));
+  if (start !== void 0 || end !== void 0) {
+    range.start = doc.positionAt(start ?? end);
+    range.end = doc.positionAt(end ?? start);
+    return true;
+  }
+  return false;
+}
+function getStyleSheetInfo(doc) {
+  var _a;
+  const parsed = parse2(doc);
+  let cached = cache.get(parsed);
+  if (!cached) {
+    const results = extractStyleSheets(doc.getText(), parsed.program, getCompilerInfo(doc).lookup);
+    cached = {};
+    for (const ext in results) {
+      const service2 = (_a = services[ext]) == null ? void 0 : _a.call(services);
+      if (!service2)
+        continue;
+      const { generated, sourceOffsetAt, generatedOffsetAt } = results[ext];
+      const virtualDoc = import_vscode_languageserver_textdocument2.TextDocument.create(doc.uri, "css", doc.version, generated);
+      cached[ext] = {
+        service: service2,
+        virtualDoc,
+        sourceOffsetAt,
+        generatedOffsetAt,
+        parsed: service2.parseStylesheet(virtualDoc)
+      };
     }
+    cache.set(parsed, cached);
   }
-  return [
-    import_vscode_languageserver9.LocationLink.create(import_vscode_uri5.URI.file(tagEntryFile).toString(), range, range, rangeFromEvent(document, event))
-  ];
+  return cached;
 }
 
+// src/service/index.ts
+var plugins = [marko_default, stylesheet_default];
+var service = {
+  async doComplete(doc, params, cancel) {
+    const result = import_vscode_languageserver11.CompletionList.create([], false);
+    try {
+      const requests = plugins.map((plugin) => {
+        var _a;
+        return (_a = plugin.doComplete) == null ? void 0 : _a.call(plugin, doc, params, cancel);
+      });
+      for (const pending of requests) {
+        const cur = await pending;
+        if (cancel.isCancellationRequested)
+          break;
+        if (cur) {
+          let items;
+          if (Array.isArray(cur)) {
+            items = cur;
+          } else {
+            items = cur.items;
+            result.isIncomplete || (result.isIncomplete = cur.isIncomplete);
+          }
+          result.items.push(...items);
+        }
+      }
+    } catch (err) {
+      result.isIncomplete = true;
+      displayError(err);
+    }
+    return result;
+  },
+  async findDefinition(doc, params, cancel) {
+    const result = [];
+    try {
+      const requests = plugins.map((plugin) => {
+        var _a;
+        return (_a = plugin.findDefinition) == null ? void 0 : _a.call(plugin, doc, params, cancel);
+      });
+      for (const pending of requests) {
+        const cur = await pending;
+        if (cancel.isCancellationRequested)
+          break;
+        if (cur) {
+          if (Array.isArray(cur)) {
+            result.push(...cur);
+          } else {
+            result.push(cur);
+          }
+        }
+      }
+    } catch (err) {
+      displayError(err);
+    }
+    return result;
+  },
+  async doHover(doc, params, cancel) {
+    var _a;
+    try {
+      for (const plugin of plugins) {
+        const result = await ((_a = plugin.doHover) == null ? void 0 : _a.call(plugin, doc, params, cancel));
+        if (cancel.isCancellationRequested)
+          return;
+        if (result)
+          return result;
+      }
+    } catch (err) {
+      displayError(err);
+    }
+  },
+  async doValidate(doc) {
+    const result = [];
+    try {
+      const requests = plugins.map((plugin) => {
+        var _a;
+        return (_a = plugin.doValidate) == null ? void 0 : _a.call(plugin, doc);
+      });
+      for (const pending of requests) {
+        const cur = await pending;
+        if (cur)
+          result.push(...cur);
+      }
+    } catch (err) {
+      displayError(err);
+    }
+    return result;
+  },
+  format: marko_default.format
+};
+
 // 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 documents = new import_node.TextDocuments(import_vscode_languageserver_textdocument3.TextDocument);
+var connection2 = (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.map((v) => (0, import_util.inspect)(v)).join(" "));
+  connection2.console.log(args.map((v) => (0, import_util2.inspect)(v)).join(" "));
 };
 console.error = (...args) => {
-  connection.console.error(args.map((v) => (0, import_util.inspect)(v)).join(" "));
+  connection2.console.error(args.map((v) => (0, import_util2.inspect)(v)).join(" "));
 };
 process.on("uncaughtException", console.error);
 process.on("unhandledRejection", console.error);
-connection.onInitialize(() => {
+connection2.onInitialize(() => {
+  setup2(connection2);
+  setup(connection2, documents);
   return {
     capabilities: {
       textDocumentSync: import_node.TextDocumentSyncKind.Incremental,
       documentFormattingProvider: true,
       definitionProvider: true,
+      hoverProvider: true,
       completionProvider: {
-        triggerCharacters: [".", ":", "<", ">", "@", "/"]
+        triggerCharacters: [
+          ".",
+          ":",
+          "<",
+          ">",
+          "@",
+          "/",
+          '"',
+          "'",
+          "`",
+          " ",
+          "=",
+          "*",
+          "#",
+          "$",
+          "+",
+          "^",
+          "(",
+          "[",
+          "-"
+        ]
       }
     }
   };
 });
-connection.onInitialized(() => {
+connection2.onInitialized(() => {
   documents.all().forEach((doc) => queueValidation(doc));
 });
-connection.onCompletion((params) => {
-  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);
+documents.onDidChangeContent((change) => {
+  queueValidation(change.document);
 });
-connection.onDefinition((params) => {
-  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);
+connection2.onCompletion(async (params, cancel) => {
+  return await service.doComplete(documents.get(params.textDocument.uri), params, cancel) || null;
 });
-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 [
-      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)), "")
-  ];
+connection2.onDefinition(async (params, cancel) => {
+  return await service.findDefinition(documents.get(params.textDocument.uri), params, cancel) || null;
 });
-connection.onDidChangeWatchedFiles(() => {
-  const clearedCompilers = /* @__PURE__ */ new Set();
-  for (const doc of documents.all()) {
-    const { compiler } = getCompilerAndTranslatorForDoc(doc);
-    if (!clearedCompilers.has(compiler)) {
-      clearCaches(compiler);
-      clearedCompilers.add(compiler);
-    }
-  }
+connection2.onHover(async (params, cancel) => {
+  return await service.doHover(documents.get(params.textDocument.uri), params, cancel) || null;
 });
-documents.onDidChangeContent((change) => {
-  queueValidation(change.document);
-  if (change.document.version > 1) {
-    clearCaches(getCompilerAndTranslatorForDoc(change.document).compiler);
-  }
+connection2.onDocumentFormatting(async (params, cancel) => {
+  return await service.format(documents.get(params.textDocument.uri), params, cancel) || null;
 });
 function queueValidation(doc) {
   clearTimeout(diagnosticTimeouts.get(doc));
-  diagnosticTimeouts.set(doc, setTimeout(() => {
+  const id = setTimeout(async () => {
     const prevDiag = prevDiagnostics.get(doc);
-    const nextDiag = doValidate(doc);
-    if (prevDiag && (0, import_util.isDeepStrictEqual)(prevDiag, nextDiag)) {
+    const nextDiag = await service.doValidate(doc) || [];
+    if (diagnosticTimeouts.get(doc) !== id || prevDiag && (0, import_util2.isDeepStrictEqual)(prevDiag, nextDiag)) {
       return;
     }
     prevDiagnostics.set(doc, nextDiag);
-    connection.sendDiagnostics({
+    connection2.sendDiagnostics({
       uri: doc.uri,
       diagnostics: nextDiag
     });
-  }, 800));
-}
-function doValidate(doc) {
-  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;
-}
-function clearCaches(compiler) {
-  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 = /* @__PURE__ */ new Map());
-  }
-  return cache;
-}
-function displayMessage(type, msg) {
-  setImmediate(() => {
-    connection.sendNotification(`show${type}`, msg);
-  });
+  }, 400);
+  diagnosticTimeouts.set(doc, id);
 }
-documents.listen(connection);
-connection.listen();
+documents.listen(connection2);
+connection2.listen();
 //# sourceMappingURL=index.js.map