@marko/language-server 0.12.17 → 1.0.0

package/dist/index.js

@@ -14,578 +14,54 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   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_languageserver_textdocument3 = require("vscode-languageserver-textdocument");
 var import_util2 = require("util");
+var import_node = require("vscode-languageserver/node");
 
-// src/utils/compiler.ts
-var import_resolve_from = __toESM(require("resolve-from"));
+// src/utils/project.ts
+var defaultCompiler = __toESM(require("@marko/compiler"));
+var defaultTranslator = __toESM(require("@marko/translator-default"));
 var import_lasso_package_root = __toESM(require("lasso-package-root"));
-var builtinCompiler = __toESM(require("@marko/compiler"));
-var builtinTranslator = __toESM(require("@marko/translator-default"));
-
-// 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;
-  }
-}
-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 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;
-      }
-      const { name } = attr;
-      if (offset > name.start && offset <= name.end) {
-        return name;
-      }
-      break;
-    }
-  }
-  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/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)({
-    onText(range) {
-      curBody.push({
-        type: 15 /* Text */,
-        parent: curParent,
-        start: range.start,
-        end: range.end
-      });
-    },
-    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;
-      }
-      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;
-          }
-          default:
-            if (nameText[0] === "@") {
-              type = 14 /* AttrTag */;
-            }
-            curBodyType = import_htmljs_parser.TagType.html;
-            break;
-        }
-      }
-      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;
-    },
-    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 = [];
-        }
-      }
-    },
-    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;
-    }
-  });
-  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;
-    }
-  } while (parentTag);
-}
-function isTransparentTag(node) {
-  return node.nameText !== void 0 && /^(?:if|else(?:-if)?|for|while)$/.test(node.nameText);
-}
-
-// src/utils/compiler.ts
-var lookupKey = Symbol("lookup");
-var compilerInfoByDir = /* @__PURE__ */ new Map();
-var builtinInfo = {
+var import_resolve_from = __toESM(require("resolve-from"));
+var cwd = process.cwd();
+var kTaglib = Symbol("taglib");
+var projectsByDir = /* @__PURE__ */ new Map();
+var defaultProject = {
+  rootDir: cwd,
   cache: /* @__PURE__ */ new Map(),
-  lookup: builtinCompiler.taglib.buildLookup(__dirname, builtinTranslator),
-  compiler: builtinCompiler,
-  translator: builtinTranslator
+  lookup: defaultCompiler.taglib.buildLookup(cwd, defaultTranslator),
+  compiler: defaultCompiler,
+  translator: defaultTranslator
 };
-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 parsed;
-}
-function getCompilerInfo(doc) {
-  const dir = getDocDir(doc);
+defaultCompiler.configure({ translator: defaultTranslator });
+function getMarkoProject(dir) {
   if (!dir)
-    return builtinInfo;
-  let info = compilerInfoByDir.get(dir);
-  if (!info) {
-    info = loadCompilerInfo(dir);
-    compilerInfoByDir.set(dir, info);
+    return defaultProject;
+  let project = projectsByDir.get(dir);
+  if (!project) {
+    project = loadProject(dir);
+    projectsByDir.set(dir, project);
   }
-  return info;
+  return project;
 }
-function clearCompilerCache(doc) {
-  if (doc) {
-    getCompilerInfo(doc).cache.delete(doc);
-  } else {
-    for (const [, info] of compilerInfoByDir) {
-      info.cache.clear();
-      info.compiler.taglib.clearCaches();
-    }
-  }
+function getMarkoProjects() {
+  return new Set(projectsByDir.values());
 }
-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");
+function loadProject(dir) {
+  const rootDir = import_lasso_package_root.default.getRootDir(dir) || cwd;
+  const pkgPath = import_resolve_from.default.silent(rootDir, "@marko/compiler/package.json");
   const pkg = pkgPath && require(pkgPath);
-  const cache4 = /* @__PURE__ */ new Map();
-  let translator = builtinTranslator;
-  let compiler = builtinCompiler;
+  const cache = /* @__PURE__ */ new Map();
+  let translator = defaultTranslator;
+  let compiler = defaultCompiler;
   if (pkg && /^5\./.test(pkg.version)) {
     try {
       let checkTranslator = [].concat(
@@ -604,16 +80,17 @@ function loadCompilerInfo(dir) {
     }
   }
   return {
-    cache: cache4,
+    rootDir,
+    cache,
     get lookup() {
-      let lookup = cache4.get(lookupKey);
+      let lookup = cache.get(kTaglib);
       if (lookup === void 0) {
         try {
           lookup = compiler.taglib.buildLookup(dir, translator);
         } catch {
-          lookup = builtinInfo.lookup;
+          lookup = defaultProject.lookup;
         }
-        cache4.set(lookupKey, lookup);
+        cache.set(kTaglib, lookup);
       }
       return lookup;
     },
@@ -622,189 +99,279 @@ function loadCompilerInfo(dir) {
   };
 }
 
-// src/utils/messages.ts
-var import_util = require("util");
-var connection;
-function setup(_) {
-  connection = _;
+// src/utils/text-documents.ts
+var import_fs = __toESM(require("fs"));
+var import_vscode_uri = require("vscode-uri");
+var import_vscode_languageserver = require("vscode-languageserver");
+var import_vscode_languageserver_textdocument = require("vscode-languageserver-textdocument");
+var docs = /* @__PURE__ */ new Map();
+var openDocs = /* @__PURE__ */ new Set();
+var fileExists = /* @__PURE__ */ new Map();
+var fileChangeHandlers = /* @__PURE__ */ new Set();
+var projectVersion = 0;
+function onFileChange(handler) {
+  fileChangeHandlers.add(handler);
 }
-function displayError(data) {
-  display("showError", data);
+function getAllOpen() {
+  return openDocs;
 }
-function display(type, data) {
-  const msg = typeof data === "string" ? data : (0, import_util.inspect)(data, { colors: false });
-  setImmediate(() => connection.sendNotification(type, msg));
+function get(uri) {
+  const doc = docs.get(uri);
+  if (doc)
+    return doc;
+  const { fsPath, scheme } = import_vscode_uri.URI.parse(uri);
+  if (scheme === "file") {
+    if (fileExists.get(uri) === false)
+      return void 0;
+    try {
+      const newDoc = import_vscode_languageserver_textdocument.TextDocument.create(
+        uri,
+        getLanguageId(uri),
+        import_fs.default.statSync(fsPath).mtimeMs,
+        import_fs.default.readFileSync(fsPath, "utf-8")
+      );
+      docs.set(uri, newDoc);
+      fileExists.set(uri, true);
+      return newDoc;
+    } catch {
+      fileExists.set(uri, false);
+    }
+  }
 }
-
-// src/service/index.ts
-var import_vscode_languageserver15 = require("vscode-languageserver");
-
-// src/service/marko/complete/index.ts
-var import_vscode_languageserver6 = 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}`
+function exists(uri) {
+  const cached = fileExists.get(uri);
+  if (cached !== void 0)
+    return cached;
+  const { fsPath, scheme } = import_vscode_uri.URI.parse(uri);
+  if (scheme === "file") {
+    try {
+      import_fs.default.accessSync(fsPath);
+      fileExists.set(uri, true);
+      return true;
+    } catch {
+      fileExists.set(uri, false);
+      return false;
+    }
+  }
+  return false;
+}
+function isOpen(doc) {
+  return openDocs.has(doc);
+}
+function setup(connection4) {
+  connection4.onDidOpenTextDocument((params) => {
+    const ref = params.textDocument;
+    const existingDoc = docs.get(ref.uri);
+    projectVersion++;
+    if (existingDoc) {
+      if (existingDoc.version === ref.version) {
+        openDocs.add(existingDoc);
+        return;
       }
-    ];
-  } 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
-        )
+      openDocs.delete(existingDoc);
+      docs.delete(ref.uri);
+    }
+    const newDoc = import_vscode_languageserver_textdocument.TextDocument.create(
+      ref.uri,
+      ref.languageId,
+      ref.version,
+      ref.text
+    );
+    openDocs.add(newDoc);
+    fileExists.set(ref.uri, true);
+    docs.set(ref.uri, newDoc);
+  });
+  connection4.onDidChangeTextDocument((params) => {
+    const ref = params.textDocument;
+    const changes = params.contentChanges;
+    const doc = docs.get(ref.uri);
+    if (changes.length > 0 && ref.version != null && doc) {
+      import_vscode_languageserver_textdocument.TextDocument.update(doc, changes, ref.version);
+      emitFileChange(doc);
+    }
+  });
+  connection4.onDidCloseTextDocument((params) => {
+    const ref = params.textDocument;
+    const doc = docs.get(ref.uri);
+    if (doc) {
+      projectVersion++;
+      openDocs.delete(doc);
+      if (import_vscode_uri.URI.parse(ref.uri).scheme !== "file") {
+        docs.delete(ref.uri);
       }
-    ];
+    }
+  });
+  connection4.onDidChangeWatchedFiles(async (params) => {
+    for (const change of params.changes) {
+      switch (change.type) {
+        case import_vscode_languageserver.FileChangeType.Created:
+          fileExists.set(change.uri, true);
+          break;
+        case import_vscode_languageserver.FileChangeType.Deleted:
+        case import_vscode_languageserver.FileChangeType.Changed: {
+          fileExists.set(change.uri, change.type === import_vscode_languageserver.FileChangeType.Changed);
+          const doc = docs.get(change.uri);
+          if (doc && !openDocs.has(doc)) {
+            docs.delete(change.uri);
+          }
+        }
+      }
+    }
+    emitFileChange(void 0);
+  });
+}
+function getLanguageId(uri) {
+  const ext = uri.slice(uri.lastIndexOf(".") + 1);
+  switch (ext) {
+    case "cjs":
+    case "mjs":
+    case "js":
+      return "javascript";
+    case "cts":
+    case "mts":
+    case "ts":
+      return "typescript";
+    default:
+      return ext;
   }
 }
-
-// src/service/marko/util/get-tag-name-completion.ts
-var import_path2 = __toESM(require("path"));
-var import_vscode_languageserver2 = require("vscode-languageserver");
-var import_vscode_uri2 = require("vscode-uri");
-var deprecated = [import_vscode_languageserver2.CompletionItemTag.Deprecated];
-function getTagNameCompletion({
-  tag,
-  range,
-  showAutoComplete,
-  importer
-}) {
-  var _a;
-  let label = tag.isNestedTag ? `@${tag.name}` : tag.name;
-  const fileForTag = tag.template || tag.renderer || tag.filePath;
-  const fileURIForTag = import_vscode_uri2.URI.file(fileForTag).toString();
-  const nodeModuleMatch = /\/node_modules\/((?:@[^/]+\/)?[^/]+)/.exec(
-    fileForTag
-  );
-  const nodeModuleName = nodeModuleMatch && nodeModuleMatch[1];
-  const isCoreTag = /^@?marko[/-]/.test(tag.taglibId) || nodeModuleName === "marko";
-  const documentation = {
-    kind: import_vscode_languageserver2.MarkupKind.Markdown,
-    value: tag.html ? `Built in [&lt;${tag.name}&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/${tag.name}) HTML tag.` : isCoreTag ? `Core Marko &lt;${tag.name}&gt; tag.` : nodeModuleName ? `Custom Marko tag discovered from the ["${nodeModuleName}"](${fileURIForTag}) npm package.` : `Custom Marko tag discovered from:
-
-[${importer ? import_path2.default.relative(importer, fileForTag) : fileForTag}](${fileURIForTag})`
-  };
-  if (tag.description) {
-    documentation.value += `
-
-${tag.description}`;
+function emitFileChange(doc) {
+  projectVersion++;
+  for (const handler of fileChangeHandlers) {
+    handler(doc);
   }
-  const autocomplete = showAutoComplete ? (_a = tag.autocomplete) == null ? void 0 : _a[0] : void 0;
-  if (autocomplete) {
-    if (autocomplete.displayText) {
-      label = autocomplete.displayText;
-    }
-    if (autocomplete.description) {
-      documentation.value += `
+}
 
-${autocomplete.description}`;
+// src/utils/workspace.ts
+var connection;
+var configChangeHandlers = /* @__PURE__ */ new Set();
+var settingsCache = /* @__PURE__ */ new Map();
+async function getConfig(section) {
+  let cached = settingsCache.get(section);
+  if (!cached) {
+    try {
+      cached = await connection.workspace.getConfiguration(section) || {};
+      settingsCache.set(section, cached);
+    } catch {
     }
-    if (autocomplete.descriptionMoreURL) {
-      documentation.value += `
+  }
+  return cached;
+}
+function onConfigChange(handler) {
+  configChangeHandlers.add(handler);
+}
+function setup2(_) {
+  connection = _;
+  connection.onDidChangeConfiguration(() => {
+    settingsCache.clear();
+    emitConfigChange();
+  });
+}
+function emitConfigChange() {
+  for (const handler of configChangeHandlers) {
+    handler();
+  }
+}
 
-[More Info](${autocomplete.descriptionMoreURL})`;
+// src/utils/messages.ts
+var import_util = require("util");
+var connection2;
+var previousMessagesByType = /* @__PURE__ */ new Map();
+function setup3(_) {
+  connection2 = _;
+}
+function displayError(data) {
+  display("showError", data);
+}
+function display(type, data) {
+  const msg = typeof data === "string" ? data : (0, import_util.inspect)(data, { colors: false });
+  const previousMessages = previousMessagesByType.get(type);
+  if (previousMessages) {
+    if (previousMessages.includes(msg))
+      return;
+    previousMessages.push(msg);
+    if (previousMessages.length > 3) {
+      previousMessages.unshift();
     }
+  } else {
+    previousMessagesByType.set(type, [msg]);
   }
-  return {
-    label,
-    documentation,
-    tags: tag.deprecated ? deprecated : void 0,
-    insertTextFormat: autocomplete ? import_vscode_languageserver2.InsertTextFormat.Snippet : void 0,
-    kind: tag.html ? import_vscode_languageserver2.CompletionItemKind.Property : import_vscode_languageserver2.CompletionItemKind.Class,
-    textEdit: range && import_vscode_languageserver2.TextEdit.replace(range, (autocomplete == null ? void 0 : autocomplete.snippet) || label)
-  };
+  setImmediate(() => connection2.sendNotification(type, msg));
 }
 
-// src/service/marko/complete/OpenTagName.ts
-function OpenTagName({
-  document,
-  lookup,
-  parsed,
-  node
-}) {
-  var _a;
-  const importer = getDocFile(document);
-  const tag = node.parent;
-  const range = parsed.locationAt(node);
-  const isAttrTag = tag.type === 14 /* AttrTag */;
-  const result = [];
-  if (isAttrTag) {
-    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);
-    if (parentTagDef) {
-      const { nestedTags } = parentTagDef;
-      for (const key in nestedTags) {
-        if (key !== "*") {
-          const tag2 = nestedTags[key];
-          result.push(
-            getTagNameCompletion({
-              tag: tag2,
-              range,
-              importer,
-              showAutoComplete: true
-            })
-          );
-        }
+// src/utils/file.ts
+var import_path = __toESM(require("path"));
+var import_language_tools = require("@marko/language-tools");
+var import_vscode_uri2 = require("vscode-uri");
+var processorCaches = /* @__PURE__ */ new WeakMap();
+function getFSDir(doc) {
+  const filename = getFSPath(doc);
+  return filename ? import_path.default.dirname(filename) : void 0;
+}
+function getFSPath(doc) {
+  return import_vscode_uri2.URI.parse(doc.uri).fsPath;
+}
+function getMarkoFile(doc) {
+  const { uri } = doc;
+  const { fsPath: filename, scheme } = import_vscode_uri2.URI.parse(uri);
+  const dirname = filename && import_path.default.dirname(filename);
+  const project = getMarkoProject(dirname);
+  const cache = project.cache;
+  let file = cache.get(doc);
+  if (!file) {
+    const { version } = doc;
+    const code = doc.getText();
+    const parsed = (0, import_language_tools.parse)(code, filename);
+    cache.set(
+      doc,
+      file = {
+        project,
+        uri,
+        scheme,
+        version,
+        filename,
+        dirname,
+        parsed,
+        code
       }
+    );
+  }
+  return file;
+}
+function processDoc(doc, process2) {
+  const file = getMarkoFile(doc);
+  const cache = processorCaches.get(file.parsed);
+  let result;
+  if (cache) {
+    result = cache.get(process2);
+    if (!result) {
+      result = process2(file);
+      cache.set(process2, result);
     }
   } else {
-    const skipStatements = !(tag.concise && tag.parent.type === 0 /* Program */);
-    for (const tag2 of lookup.getTagsSorted()) {
-      if (!(tag2.name === "*" || tag2.isNestedTag || skipStatements && ((_a = tag2.parseOptions) == null ? void 0 : _a.statement) || tag2.name[0] === "_" && /^@?marko[/-]|[\\/]node_modules[\\/]/.test(tag2.filePath))) {
-        result.push(
-          getTagNameCompletion({
-            tag: tag2,
-            range,
-            importer,
-            showAutoComplete: true
-          })
-        );
-      }
-    }
+    result = process2(file);
+    processorCaches.set(file.parsed, /* @__PURE__ */ new Map([[process2, result]]));
   }
   return result;
 }
 
+// src/service/index.ts
+var import_vscode_languageserver12 = require("vscode-languageserver");
+
+// src/service/marko/complete/index.ts
+var import_language_tools5 = require("@marko/language-tools");
+
 // src/service/marko/complete/AttrName.ts
-var import_vscode_languageserver3 = require("vscode-languageserver");
+var import_vscode_languageserver2 = require("vscode-languageserver");
 function AttrName({
   offset,
   node,
-  parsed,
-  lookup
+  file: {
+    parsed,
+    project: { lookup }
+  }
 }) {
   let name = parsed.read(node);
-  if (name[0] === "{")
-    return;
   const modifierIndex = name.indexOf(":");
   const hasModifier = modifierIndex !== -1;
   if (hasModifier) {
@@ -812,12 +379,12 @@ function AttrName({
       return [
         {
           label: "scoped",
-          kind: import_vscode_languageserver3.CompletionItemKind.Keyword,
+          kind: import_vscode_languageserver2.CompletionItemKind.Keyword,
           detail: "Use to prefix with a unique ID"
         },
         {
           label: "no-update",
-          kind: import_vscode_languageserver3.CompletionItemKind.Keyword,
+          kind: import_vscode_languageserver2.CompletionItemKind.Keyword,
           detail: "Use to skip future updates to this attribute"
         }
       ];
@@ -835,25 +402,19 @@ function AttrName({
   const tagName = node.parent.parent.nameText || "";
   const tagDef = tagName && lookup.getTag(tagName);
   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;
     }
   }
-  lookup.forEachAttribute(tagName, (attr) => {
-    if (attr.type === "never") {
-      neverAttrs.add(attr.name);
-    }
-  });
   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)) {
+    if (attr.deprecated || nestedTagAttrs[attr.name] || attr.name === "*" || attr.type === "never" || attr.name[0] === "_" && isExternalModule(attr.filePath || parent.filePath)) {
       return;
     }
     const type = attr.type || (attr.html ? "string" : null);
     const documentation = {
-      kind: import_vscode_languageserver3.MarkupKind.Markdown,
+      kind: import_vscode_languageserver2.MarkupKind.Markdown,
       value: attr.description || ""
     };
     let label = attr.name;
@@ -893,19 +454,23 @@ function AttrName({
     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(attrNameLoc, snippet)
+      kind: import_vscode_languageserver2.CompletionItemKind.Property,
+      insertTextFormat: import_vscode_languageserver2.InsertTextFormat.Snippet,
+      textEdit: import_vscode_languageserver2.TextEdit.replace(attrNameLoc, snippet)
     });
   });
   return completions;
 }
+function isExternalModule(file) {
+  return /[/\\]node_modules[/\\]/.test(file) || !/^(?:[A-Za-z]:\\|[./\\])/.test(file);
+}
 
 // src/service/marko/complete/AttrValue.ts
-var import_path3 = __toESM(require("path"));
-var import_vscode_languageserver4 = require("vscode-languageserver");
+var import_path2 = __toESM(require("path"));
+var import_vscode_languageserver3 = require("vscode-languageserver");
 
 // src/service/marko/util/is-document-link-attr.ts
+var import_language_tools2 = require("@marko/language-tools");
 var linkedAttrs = /* @__PURE__ */ new Map([
   [
     "src",
@@ -925,15 +490,15 @@ var linkedAttrs = /* @__PURE__ */ new Map([
   ["data", /* @__PURE__ */ new Set(["object"])],
   ["poster", /* @__PURE__ */ new Set(["video"])]
 ]);
-function isDocumentLinkAttr(doc, tag, attr) {
+function isDocumentLinkAttr(code, tag, attr) {
   var _a, _b;
-  return tag.nameText && attr.type === 8 /* AttrNamed */ && ((_a = attr.value) == null ? void 0 : _a.type) === 11 /* AttrValue */ && /^['"]$/.test(doc.getText()[attr.value.value.start]) && ((_b = linkedAttrs.get(doc.getText().slice(attr.name.start, attr.name.end))) == null ? void 0 : _b.has(tag.nameText)) || false;
+  return tag.nameText && attr.type === import_language_tools2.NodeType.AttrNamed && ((_a = attr.value) == null ? void 0 : _a.type) === import_language_tools2.NodeType.AttrValue && /^['"]$/.test(code[attr.value.value.start]) && ((_b = linkedAttrs.get(code.slice(attr.name.start, attr.name.end))) == null ? void 0 : _b.has(tag.nameText)) || false;
 }
 
 // src/utils/file-system.ts
 var import_promises = __toESM(require("fs/promises"));
-var import_vscode_css_languageservice = require("vscode-css-languageservice");
 var import_url = require("url");
+var import_vscode_css_languageservice = require("vscode-css-languageservice");
 var file_system_default = {
   stat,
   readDirectory
@@ -962,17 +527,18 @@ async function stat(uri) {
   };
 }
 async function readDirectory(uri) {
+  const result = [];
   try {
-    const entries = await import_promises.default.readdir((0, import_url.fileURLToPath)(uri));
-    const base = uri.at(-1) === "/" ? uri : `${uri}/`;
-    return (await Promise.all(
-      entries.map(
-        async (entry) => [entry, (await stat(new URL(entry, base).toString())).type]
-      )
-    )).filter(([, type]) => type !== import_vscode_css_languageservice.FileType.Unknown);
+    for await (const entry of await import_promises.default.opendir((0, import_url.fileURLToPath)(uri))) {
+      if (entry.isFile()) {
+        result.push([entry.name, import_vscode_css_languageservice.FileType.File]);
+      } else if (entry.isDirectory()) {
+        result.push([entry.name, import_vscode_css_languageservice.FileType.Directory]);
+      }
+    }
   } catch {
-    return [];
   }
+  return result;
 }
 
 // src/utils/resolve-url.ts
@@ -988,14 +554,12 @@ function resolveUrl(to, base) {
 
 // src/service/marko/complete/AttrValue.ts
 async function AttrValue({
-  document,
   offset,
   node,
-  parsed,
-  code
+  file: { uri, parsed, code }
 }) {
   const attr = node.parent;
-  if (isDocumentLinkAttr(document, attr.parent, attr)) {
+  if (isDocumentLinkAttr(code, attr.parent, attr)) {
     const start = node.value.start + 1;
     if (code[start] !== ".")
       return;
@@ -1009,29 +573,29 @@ async function AttrValue({
     if (segmentStart === -1)
       return;
     const req = rawValue.slice(0, segmentStart);
-    const uri = resolveUrl(req, document.uri);
-    if (uri) {
+    const resolved = resolveUrl(req, uri);
+    if (resolved) {
       const result = [];
-      const curFile = req === "." ? import_path3.default.basename(document.uri) : void 0;
-      const replaceRange = import_vscode_languageserver4.Range.create(
-        document.positionAt(start + segmentStart + 1),
-        document.positionAt(start + rawValue.length)
-      );
-      for (const [entry, type] of await file_system_default.readDirectory(uri)) {
+      const curFile = req === "." ? import_path2.default.basename(uri) : void 0;
+      const replaceRange = parsed.locationAt({
+        start: start + segmentStart + 1,
+        end: start + rawValue.length
+      });
+      for (const [entry, type] of await file_system_default.readDirectory(resolved)) {
         if (entry[0] !== "." && entry !== curFile) {
           result.push(
             type === import_vscode_css_languageservice.FileType.Directory ? {
               label: `${entry}/`,
-              kind: import_vscode_languageserver4.CompletionItemKind.Folder,
-              textEdit: import_vscode_languageserver4.TextEdit.replace(replaceRange, `${entry}/`),
+              kind: import_vscode_languageserver3.CompletionItemKind.Folder,
+              textEdit: import_vscode_languageserver3.TextEdit.replace(replaceRange, `${entry}/`),
               command: {
                 title: "Suggest",
                 command: "editor.action.triggerSuggest"
               }
             } : {
               label: entry,
-              kind: import_vscode_languageserver4.CompletionItemKind.File,
-              textEdit: import_vscode_languageserver4.TextEdit.replace(replaceRange, entry)
+              kind: import_vscode_languageserver3.CompletionItemKind.File,
+              textEdit: import_vscode_languageserver3.TextEdit.replace(replaceRange, entry)
             }
           );
         }
@@ -1041,43 +605,200 @@ async function AttrValue({
   }
 }
 
-// src/service/marko/complete/Statement.ts
+// src/service/marko/complete/Import.ts
 var import_vscode_languageserver5 = require("vscode-languageserver");
-var importTagReg = /(['"])<((?:[^\1\\>]+|\\.)*)>?\1/g;
-function Statement({
-  code,
+
+// src/service/marko/util/get-tag-name-completion.ts
+var import_path3 = __toESM(require("path"));
+var import_vscode_languageserver4 = require("vscode-languageserver");
+var import_vscode_uri3 = require("vscode-uri");
+var deprecated = [import_vscode_languageserver4.CompletionItemTag.Deprecated];
+function getTagNameCompletion({
+  tag,
+  range,
+  showAutoComplete,
+  importer
+}) {
+  var _a;
+  let label = tag.isNestedTag ? `@${tag.name}` : tag.name;
+  const fileForTag = tag.template || tag.renderer || tag.filePath;
+  const fileURIForTag = import_vscode_uri3.URI.file(fileForTag).toString();
+  const nodeModuleMatch = /\/node_modules\/((?:@[^/]+\/)?[^/]+)/.exec(
+    fileForTag
+  );
+  const nodeModuleName = nodeModuleMatch && nodeModuleMatch[1];
+  const isCoreTag = /^@?marko[/-]/.test(tag.taglibId || tag.filePath) || nodeModuleName === "marko";
+  const documentation = {
+    kind: import_vscode_languageserver4.MarkupKind.Markdown,
+    value: tag.html ? `Built in [&lt;${tag.name}&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/${tag.name}) HTML tag.` : isCoreTag ? `Core Marko &lt;${tag.name}&gt; tag.` : nodeModuleName ? `Custom Marko tag discovered from the ["${nodeModuleName}"](${fileURIForTag}) npm package.` : `Custom Marko tag discovered from:
+
+[${importer ? import_path3.default.relative(importer, fileForTag) : fileForTag}](${fileURIForTag})`
+  };
+  if (tag.description) {
+    documentation.value += `
+
+${tag.description}`;
+  }
+  const autocomplete = showAutoComplete ? (_a = tag.autocomplete) == null ? void 0 : _a[0] : void 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,
+    tags: tag.deprecated ? deprecated : void 0,
+    insertTextFormat: autocomplete ? import_vscode_languageserver4.InsertTextFormat.Snippet : void 0,
+    kind: tag.html ? import_vscode_languageserver4.CompletionItemKind.Property : import_vscode_languageserver4.CompletionItemKind.Class,
+    textEdit: range && import_vscode_languageserver4.TextEdit.replace(range, (autocomplete == null ? void 0 : autocomplete.snippet) || label)
+  };
+}
+
+// src/service/marko/complete/Import.ts
+var importTagReg = /(['"])<((?:[^\1\\>]+|\\.)*)>?\1/;
+function Import({
   node,
-  parsed,
-  lookup,
-  document
+  file: {
+    parsed,
+    filename,
+    project: { lookup }
+  }
 }) {
   var _a;
-  if (code[node.start] === "i") {
-    importTagReg.lastIndex = 0;
-    const value = parsed.read(node);
-    const match = importTagReg.exec(value);
-    if (match) {
-      const importer = getDocFile(document);
-      const [{ length }] = match;
-      const range = parsed.locationAt({
-        start: node.start + match.index + 1,
-        end: node.start + match.index + length - 1
-      });
-      const result = [];
-      for (const tag of lookup.getTagsSorted()) {
-        if ((tag.template || tag.renderer) && !(tag.html || tag.parser || tag.translator || tag.isNestedTag || tag.name === "*" || ((_a = tag.parseOptions) == null ? void 0 : _a.statement) || /^@?marko[/-]/.test(tag.taglibId) || tag.name[0] === "_" && /[\\/]node_modules[\\/]/.test(tag.filePath))) {
-          const completion = getTagNameCompletion({
-            tag,
-            importer
-          });
-          completion.label = `<${completion.label}>`;
-          completion.textEdit = import_vscode_languageserver5.TextEdit.replace(range, completion.label);
-          result.push(completion);
+  const value = parsed.read(node);
+  const match = importTagReg.exec(value);
+  if (match) {
+    const [{ length }] = match;
+    const fromStart = node.start + match.index;
+    const range = parsed.locationAt({
+      start: fromStart + 1,
+      end: fromStart + length - 1
+    });
+    const result = [];
+    for (const tag of lookup.getTagsSorted()) {
+      if ((tag.template || tag.renderer) && !(tag.html || tag.parser || tag.translator || tag.isNestedTag || tag.name === "*" || ((_a = tag.parseOptions) == null ? void 0 : _a.statement) || /^@?marko[/-]/.test(tag.taglibId) || tag.name[0] === "_" && /[\\/]node_modules[\\/]/.test(tag.filePath))) {
+        const completion = getTagNameCompletion({
+          tag,
+          importer: filename
+        });
+        completion.label = `<${completion.label}>`;
+        completion.textEdit = import_vscode_languageserver5.TextEdit.replace(range, completion.label);
+        result.push(completion);
+      }
+    }
+    return result;
+  }
+}
+
+// src/service/marko/complete/OpenTagName.ts
+var import_language_tools3 = require("@marko/language-tools");
+function OpenTagName({
+  node,
+  file: {
+    parsed,
+    filename,
+    project: { lookup }
+  }
+}) {
+  var _a;
+  const tag = node.parent;
+  const range = parsed.locationAt(node);
+  const isAttrTag = tag.type === import_language_tools3.NodeType.AttrTag;
+  const result = [];
+  if (isAttrTag) {
+    let parentTag = tag.owner;
+    while ((parentTag == null ? void 0 : parentTag.type) === import_language_tools3.NodeType.AttrTag)
+      parentTag = parentTag.owner;
+    const parentTagDef = parentTag && parentTag.nameText && lookup.getTag(parentTag.nameText);
+    if (parentTagDef) {
+      const { nestedTags } = parentTagDef;
+      for (const key in nestedTags) {
+        if (key !== "*") {
+          const tag2 = nestedTags[key];
+          result.push(
+            getTagNameCompletion({
+              tag: tag2,
+              range,
+              importer: filename,
+              showAutoComplete: true
+            })
+          );
         }
       }
-      return result;
+    }
+  } else {
+    const skipStatements = !(tag.concise && tag.parent.type === import_language_tools3.NodeType.Program);
+    for (const tag2 of lookup.getTagsSorted()) {
+      if (!(tag2.name === "*" || tag2.isNestedTag || skipStatements && ((_a = tag2.parseOptions) == null ? void 0 : _a.statement) || tag2.name[0] === "_" && /^@?marko[/-]|[\\/]node_modules[\\/]/.test(tag2.filePath))) {
+        const completion = getTagNameCompletion({
+          tag: tag2,
+          range,
+          importer: filename,
+          showAutoComplete: true
+        });
+        completion.sortText = `0${completion.label}`;
+        result.push(completion);
+      }
     }
   }
+  return result;
+}
+
+// src/service/marko/complete/Tag.ts
+var import_vscode_languageserver6 = require("vscode-languageserver");
+var import_language_tools4 = require("@marko/language-tools");
+var partialCloseTagReg = /<\/(?:[^><]*>)?/iy;
+function Tag({
+  node,
+  offset,
+  file: { parsed, code }
+}) {
+  const isClosed = node.end !== import_language_tools4.UNFINISHED;
+  if (isClosed || node.concise)
+    return;
+  const closingTagStr = `</${node.nameText || ""}>`;
+  if (offset === node.open.end) {
+    return [
+      {
+        label: closingTagStr,
+        kind: import_vscode_languageserver6.CompletionItemKind.Class,
+        insertTextFormat: import_vscode_languageserver6.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_languageserver6.CompletionItemKind.Class,
+        insertTextFormat: import_vscode_languageserver6.InsertTextFormat.Snippet,
+        textEdit: import_vscode_languageserver6.TextEdit.replace(
+          parsed.locationAt({
+            start,
+            end
+          }),
+          closingTagStr
+        )
+      }
+    ];
+  }
 }
 
 // src/service/marko/complete/index.ts
@@ -1086,37 +807,37 @@ var handlers = {
   OpenTagName,
   AttrName,
   AttrValue,
-  Statement
+  Import
 };
 var doComplete = async (doc, params) => {
   var _a;
-  const parsed = parse2(doc);
+  const file = getMarkoFile(doc);
   const offset = doc.offsetAt(params.position);
-  const node = parsed.nodeAt(offset);
-  return import_vscode_languageserver6.CompletionList.create(
-    await ((_a = handlers[NodeType[node.type]]) == null ? void 0 : _a.call(handlers, {
-      document: doc,
+  const node = file.parsed.nodeAt(offset);
+  return {
+    items: await ((_a = handlers[import_language_tools5.NodeType[node.type]]) == null ? void 0 : _a.call(handlers, {
+      file,
       params,
-      parsed,
       offset,
-      node,
-      code: doc.getText(),
-      ...getCompilerInfo(doc)
+      node
     })) || [],
-    true
-  );
+    isIncomplete: true
+  };
 };
 
 // src/service/marko/validate.ts
+var import_path4 = __toESM(require("path"));
 var import_vscode_languageserver7 = require("vscode-languageserver");
 var markoErrorRegExp = /^(.+?)\.marko(?:\((\d+)(?:\s*,\s*(\d+))?\))?: (.*)$/gm;
 var doValidate = (doc) => {
-  const fsPath = getDocFile(doc);
+  const filename = getFSPath(doc);
   const diagnostics = [];
-  const { compiler, translator, cache: cache4 } = getCompilerInfo(doc);
+  const { compiler, translator, cache } = getMarkoProject(
+    filename && import_path4.default.dirname(filename)
+  );
   try {
-    compiler.compileSync(doc.getText(), fsPath || "untitled.marko", {
-      cache: cache4,
+    compiler.compileSync(doc.getText(), filename || "untitled.marko", {
+      cache,
       translator,
       code: false,
       output: "source",
@@ -1152,42 +873,43 @@ var doValidate = (doc) => {
   return diagnostics;
 };
 
-// src/utils/utils.ts
-var import_fs = __toESM(require("fs"));
-var import_vscode_uri3 = require("vscode-uri");
-var import_vscode_languageserver8 = require("vscode-languageserver");
-var import_vscode_languageserver_textdocument = require("vscode-languageserver-textdocument");
-var START_OF_FILE = import_vscode_languageserver8.Range.create(
-  import_vscode_languageserver8.Position.create(0, 0),
-  import_vscode_languageserver8.Position.create(0, 0)
-);
-function createTextDocument(filename) {
-  const uri = import_vscode_uri3.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/hover/index.ts
+var import_language_tools6 = require("@marko/language-tools");
+
+// src/utils/constants.ts
+var START_POSITION = {
+  line: 0,
+  character: 0
+};
+var START_LOCATION = {
+  start: START_POSITION,
+  end: START_POSITION
+};
 
 // src/service/marko/hover/OpenTagName.ts
 function OpenTagName2({
-  document,
-  lookup,
-  parsed,
-  node
+  node,
+  file: {
+    parsed,
+    filename,
+    project: { lookup }
+  }
 }) {
-  const importer = getDocFile(document);
   const tag = node.parent;
   const range = parsed.locationAt(node);
   const tagDef = tag.nameText && lookup.getTag(tag.nameText);
   if (tagDef) {
     const completion = getTagNameCompletion({
       tag: tagDef,
-      range: START_OF_FILE,
-      importer
+      range: START_LOCATION,
+      importer: filename
     });
-    return {
-      range,
-      contents: completion.documentation
-    };
+    if (completion.documentation) {
+      return {
+        range,
+        contents: completion.documentation
+      };
+    }
   }
 }
 
@@ -1197,24 +919,24 @@ var handlers2 = {
 };
 var doHover = async (doc, params) => {
   var _a;
-  const parsed = parse2(doc);
+  const file = getMarkoFile(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,
+  const node = file.parsed.nodeAt(offset);
+  return await ((_a = handlers2[import_language_tools6.NodeType[node.type]]) == null ? void 0 : _a.call(handlers2, {
+    file,
     params,
-    parsed,
     offset,
-    node,
-    code: doc.getText(),
-    ...getCompilerInfo(doc)
+    node
   }));
 };
 
-// src/service/marko/definition/OpenTagName.ts
-var import_path4 = __toESM(require("path"));
+// src/service/marko/definition/index.ts
+var import_language_tools9 = require("@marko/language-tools");
+
+// src/service/marko/definition/AttrName.ts
+var import_fs2 = __toESM(require("fs"));
 var import_vscode_uri4 = require("vscode-uri");
-var import_vscode_languageserver9 = require("vscode-languageserver");
+var import_language_tools7 = require("@marko/language-tools");
 
 // src/utils/regexp-builder.ts
 function RegExpBuilder(strings, ...expressions) {
@@ -1240,18 +962,67 @@ function escape(val) {
   return String(val).replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 }
 
+// src/service/marko/definition/AttrName.ts
+function AttrName2({
+  node,
+  file: {
+    parsed,
+    project: { lookup }
+  }
+}) {
+  const tagName = node.parent.parent.nameText;
+  const attrName = parsed.read(node);
+  const tagDef = tagName ? lookup.getTag(tagName) : void 0;
+  const attrDef = lookup.getAttribute(tagName || "", attrName);
+  let range = START_LOCATION;
+  if (!attrDef) {
+    return;
+  }
+  const attrEntryFile = attrDef.filePath || (tagDef == null ? void 0 : tagDef.filePath);
+  if (!attrEntryFile) {
+    return;
+  }
+  if (/\.json$/.test(attrEntryFile)) {
+    const tagDefSource = import_fs2.default.readFileSync(attrEntryFile, "utf-8");
+    const match = RegExpBuilder`/"@${attrName}"\s*:\s*[^\r\n,]+/g`.exec(
+      tagDefSource
+    );
+    if (match && match.index) {
+      range = (0, import_language_tools7.getLocation)(
+        (0, import_language_tools7.getLines)(tagDefSource),
+        match.index,
+        match.index + match[0].length
+      );
+    }
+    return [
+      {
+        targetUri: import_vscode_uri4.URI.file(attrEntryFile).toString(),
+        targetRange: range,
+        targetSelectionRange: range,
+        originSelectionRange: parsed.locationAt(node)
+      }
+    ];
+  }
+}
+
 // src/service/marko/definition/OpenTagName.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var import_vscode_uri5 = require("vscode-uri");
+var import_language_tools8 = require("@marko/language-tools");
 function OpenTagName3({
-  lookup,
-  parsed,
-  node
+  node,
+  file: {
+    parsed,
+    project: { lookup }
+  }
 }) {
   const tag = node.parent;
   let tagDef;
-  let range = START_OF_FILE;
-  if (tag.type === 14 /* AttrTag */) {
+  let range = START_LOCATION;
+  if (tag.type === import_language_tools8.NodeType.AttrTag) {
     let parentTag = tag.owner;
-    while ((parentTag == null ? void 0 : parentTag.type) === 14 /* AttrTag */)
+    while ((parentTag == null ? void 0 : parentTag.type) === import_language_tools8.NodeType.AttrTag)
       parentTag = parentTag.owner;
     tagDef = parentTag && parentTag.nameText ? lookup.getTag(parentTag.nameText) : void 0;
   } else {
@@ -1261,72 +1032,29 @@ function OpenTagName3({
     return;
   }
   const tagEntryFile = tagDef.template || tagDef.renderer || tagDef.filePath;
-  if (!import_path4.default.isAbsolute(tagEntryFile)) {
+  if (!import_path5.default.isAbsolute(tagEntryFile)) {
     return;
   }
   if (/\/marko(?:-tag)?\.json$/.test(tagEntryFile)) {
-    const tagDefDoc = createTextDocument(tagEntryFile);
+    const tagDefSource = import_fs3.default.readFileSync(tagEntryFile, "utf-8");
     const match = RegExpBuilder`/"(?:<${tag.nameText}>|${tag.nameText})"\s*:\s*[^\r\n,]+/g`.exec(
-      tagDefDoc.getText()
+      tagDefSource
     );
     if (match && match.index) {
-      range = import_vscode_languageserver9.Range.create(
-        tagDefDoc.positionAt(match.index),
-        tagDefDoc.positionAt(match.index + match[0].length)
+      range = (0, import_language_tools8.getLocation)(
+        (0, import_language_tools8.getLines)(tagDefSource),
+        match.index,
+        match.index + match[0].length
       );
     }
   }
   return [
-    import_vscode_languageserver9.LocationLink.create(
-      import_vscode_uri4.URI.file(tagEntryFile).toString(),
-      range,
-      range,
-      parsed.locationAt(node)
-    )
-  ];
-}
-
-// src/service/marko/definition/AttrName.ts
-var import_vscode_uri5 = require("vscode-uri");
-var import_vscode_languageserver10 = 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;
-  }
-  const attrEntryFile = attrDef.filePath || tagDef && tagDef.filePath;
-  if (!attrEntryFile) {
-    return;
-  }
-  if (/\/marko(?:-tag)?\.json$/.test(attrEntryFile)) {
-    const tagDefDoc = createTextDocument(attrEntryFile);
-    const match = RegExpBuilder`/"@${attrName}"\s*:\s*[^\r\n,]+/g`.exec(
-      tagDefDoc.getText()
-    );
-    if (match && match.index) {
-      range = import_vscode_languageserver10.Range.create(
-        tagDefDoc.positionAt(match.index),
-        tagDefDoc.positionAt(match.index + match[0].length)
-      );
+    {
+      targetUri: import_vscode_uri5.URI.file(tagEntryFile).toString(),
+      targetRange: range,
+      targetSelectionRange: range,
+      originSelectionRange: parsed.locationAt(node)
     }
-  }
-  return [
-    import_vscode_languageserver10.LocationLink.create(
-      import_vscode_uri5.URI.file(attrEntryFile).toString(),
-      range,
-      range,
-      parsed.locationAt(node)
-    )
   ];
 }
 
@@ -1337,66 +1065,57 @@ var handlers3 = {
 };
 var findDefinition = async (doc, params) => {
   var _a;
-  const parsed = parse2(doc);
+  const file = getMarkoFile(doc);
   const offset = doc.offsetAt(params.position);
-  const node = parsed.nodeAt(offset);
-  return await ((_a = handlers3[NodeType[node.type]]) == null ? void 0 : _a.call(handlers3, {
-    document: doc,
+  const node = file.parsed.nodeAt(offset);
+  return await ((_a = handlers3[import_language_tools9.NodeType[node.type]]) == null ? void 0 : _a.call(handlers3, {
+    file,
     params,
-    parsed,
     offset,
-    node,
-    code: doc.getText(),
-    ...getCompilerInfo(doc)
+    node
   })) || [];
 };
 
 // src/service/marko/document-links.ts
-var import_vscode_languageserver11 = require("vscode-languageserver");
-var import_vscode_uri6 = require("vscode-uri");
+var import_language_tools10 = require("@marko/language-tools");
 var importTagReg2 = /(['"])<((?:[^\1\\>]+|\\.)*)>?\1/g;
-var cache = /* @__PURE__ */ new WeakMap();
 var findDocumentLinks = async (doc) => {
-  const parsed = parse2(doc);
-  let result = cache.get(parsed);
-  if (!result) {
-    result = extractDocumentLinks(doc, parsed, getCompilerInfo(doc).lookup);
-    cache.set(parsed, result);
-  }
-  return result;
+  return processDoc(doc, extractDocumentLinks);
 };
-function extractDocumentLinks(doc, parsed, lookup) {
-  if (import_vscode_uri6.URI.parse(doc.uri).scheme === "untitled") {
+function extractDocumentLinks({
+  uri,
+  scheme,
+  parsed,
+  code,
+  project: { lookup }
+}) {
+  if (scheme !== "file") {
     return [];
   }
   const links = [];
-  const { program } = parsed;
-  const code = doc.getText();
-  const read = (range) => code.slice(range.start, range.end);
+  const { program, read } = parsed;
   const visit = (node) => {
     switch (node.type) {
-      case 14 /* AttrTag */:
+      case import_language_tools10.NodeType.AttrTag:
         if (node.body) {
           for (const child of node.body) {
             visit(child);
           }
         }
         break;
-      case 1 /* Tag */:
+      case import_language_tools10.NodeType.Tag:
         if (node.attrs && node.nameText) {
           for (const attr of node.attrs) {
-            if (isDocumentLinkAttr(doc, node, attr)) {
+            if (isDocumentLinkAttr(code, node, attr)) {
               const resolved = resolveUrl(
                 read(attr.value.value).slice(1, -1),
-                doc.uri
+                uri
               );
               if (resolved) {
-                links.push(
-                  import_vscode_languageserver11.DocumentLink.create(
-                    parsed.locationAt(attr.value.value),
-                    resolveUrl(read(attr.value.value).slice(1, -1), doc.uri)
-                  )
-                );
+                links.push({
+                  range: parsed.locationAt(attr.value.value),
+                  target: resolveUrl(read(attr.value.value).slice(1, -1), uri)
+                });
               }
             }
           }
@@ -1409,50 +1128,44 @@ function extractDocumentLinks(doc, parsed, lookup) {
         break;
     }
   };
-  for (const item of program.static) {
-    if (item.type === 20 /* Statement */ && code[item.start] === "i") {
+  for (const node of program.static) {
+    if (node.type === import_language_tools10.NodeType.Import) {
       importTagReg2.lastIndex = 0;
-      const value = parsed.read(item);
+      const value = parsed.read(node);
       const match = importTagReg2.exec(value);
       if (match) {
         const [{ length }, , tagName] = match;
         const tagDef = lookup.getTag(tagName);
         const fileForTag = tagDef && (tagDef.template || tagDef.renderer);
         if (fileForTag) {
-          links.push(
-            import_vscode_languageserver11.DocumentLink.create(
-              parsed.locationAt({
-                start: item.start + match.index,
-                end: item.start + match.index + length
-              }),
-              fileForTag
-            )
-          );
+          links.push({
+            range: parsed.locationAt({
+              start: node.start + match.index,
+              end: node.start + match.index + length
+            }),
+            target: fileForTag
+          });
         }
       }
     }
   }
-  for (const item of program.body) {
-    visit(item);
+  for (const node of program.body) {
+    visit(node);
   }
   return links;
 }
 
 // src/service/marko/document-symbols.ts
-var import_vscode_uri7 = require("vscode-uri");
-var import_vscode_languageserver12 = require("vscode-languageserver");
-var cache2 = /* @__PURE__ */ new WeakMap();
-var findDocumentSymbols = async (doc) => {
-  const parsed = parse2(doc);
-  let result = cache2.get(parsed);
-  if (!result) {
-    result = extractDocumentSymbols(doc, parsed, getCompilerInfo(doc).lookup);
-    cache2.set(parsed, result);
-  }
-  return result;
-};
-function extractDocumentSymbols(doc, parsed, lookup) {
-  if (import_vscode_uri7.URI.parse(doc.uri).scheme === "untitled") {
+var import_vscode_languageserver8 = require("vscode-languageserver");
+var import_language_tools11 = require("@marko/language-tools");
+var findDocumentSymbols = async (doc) => processDoc(doc, extractDocumentSymbols);
+function extractDocumentSymbols({
+  uri,
+  scheme,
+  parsed,
+  project: { lookup }
+}) {
+  if (scheme !== "file") {
     return [];
   }
   const symbols = [];
@@ -1460,16 +1173,16 @@ function extractDocumentSymbols(doc, parsed, lookup) {
   const visit = (node) => {
     var _a, _b;
     switch (node.type) {
-      case 1 /* Tag */:
-      case 14 /* AttrTag */:
-        symbols.push(
-          import_vscode_languageserver12.SymbolInformation.create(
-            (node.type === 14 /* AttrTag */ ? (_a = node.nameText) == null ? void 0 : _a.slice(node.nameText.indexOf("@")) : node.nameText) || "<${...}>",
-            node.nameText && ((_b = lookup.getTag(node.nameText)) == null ? void 0 : _b.html) && import_vscode_languageserver12.SymbolKind.Property || import_vscode_languageserver12.SymbolKind.Class,
-            parsed.locationAt(node),
-            doc.uri
-          )
-        );
+      case import_language_tools11.NodeType.Tag:
+      case import_language_tools11.NodeType.AttrTag:
+        symbols.push({
+          name: (node.type === import_language_tools11.NodeType.AttrTag ? (_a = node.nameText) == null ? void 0 : _a.slice(node.nameText.indexOf("@")) : node.nameText) || "<${...}>",
+          kind: node.nameText && ((_b = lookup.getTag(node.nameText)) == null ? void 0 : _b.html) && import_vscode_languageserver8.SymbolKind.Property || import_vscode_languageserver8.SymbolKind.Class,
+          location: {
+            uri,
+            range: parsed.locationAt(node)
+          }
+        });
         if (node.body) {
           for (const child of node.body) {
             visit(child);
@@ -1485,32 +1198,35 @@ function extractDocumentSymbols(doc, parsed, lookup) {
 }
 
 // src/service/marko/format.ts
-var import_vscode_languageserver13 = require("vscode-languageserver");
-var import_vscode_uri8 = require("vscode-uri");
+var import_vscode_languageserver9 = require("vscode-languageserver");
 var prettier = __toESM(require("prettier"));
 var markoPrettier = __toESM(require("prettier-plugin-marko"));
 var format2 = async (doc, params, cancel) => {
   try {
-    const { fsPath, scheme } = import_vscode_uri8.URI.parse(doc.uri);
+    const filepath = getFSPath(doc);
     const text = doc.getText();
     const options = {
       parser: "marko",
-      filepath: fsPath,
+      filepath,
       plugins: [markoPrettier],
       tabWidth: params.options.tabSize,
       useTabs: params.options.insertSpaces === false,
-      ...scheme === "file" ? await prettier.resolveConfig(fsPath, {
+      ...filepath ? await prettier.resolveConfig(filepath, {
         editorconfig: true
       }).catch(() => null) : null
     };
     if (cancel.isCancellationRequested)
       return;
-    return [
-      import_vscode_languageserver13.TextEdit.replace(
-        import_vscode_languageserver13.Range.create(doc.positionAt(0), doc.positionAt(text.length)),
+    const ret = [
+      import_vscode_languageserver9.TextEdit.replace(
+        {
+          start: START_POSITION,
+          end: doc.positionAt(text.length)
+        },
         prettier.format(text, options)
       )
     ];
+    return ret;
   } catch (e) {
     displayError(e);
   }
@@ -1527,181 +1243,932 @@ var marko_default = {
   format: format2
 };
 
-// src/service/stylesheet/index.ts
-var import_vscode_languageserver14 = require("vscode-languageserver");
-var import_vscode_css_languageservice2 = require("vscode-css-languageservice");
-var import_vscode_languageserver_textdocument2 = require("vscode-languageserver-textdocument");
+// src/service/script/index.ts
+var import_path9 = __toESM(require("path"));
+var import_relative_import_path = require("relative-import-path");
+var import_tsserverlibrary = __toESM(require("typescript/lib/tsserverlibrary"));
+var import_vscode_languageserver10 = require("vscode-languageserver");
+var import_vscode_uri6 = require("vscode-uri");
+var prettier2 = __toESM(require("prettier"));
+var import_language_tools14 = require("@marko/language-tools");
 
-// 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);
-        }
+// src/ts-plugin/host.ts
+var import_path8 = __toESM(require("path"));
+var import_language_tools13 = require("@marko/language-tools");
+
+// src/utils/get-runtime-types.ts
+var import_path6 = __toESM(require("path"));
+var internalTypesFile = import_path6.default.join(__dirname, "marko.internal.d.ts");
+var defaultMarkoTypesFile = import_path6.default.join(__dirname, "marko.runtime.d.ts");
+function getProjectTypeLibs(project, ts2, host) {
+  let cached = project.cache.get(getProjectTypeLibs);
+  if (cached === void 0) {
+    const { resolvedTypeReferenceDirective } = ts2.resolveTypeReferenceDirective(
+      project.translator.runtimeTypes || "marko",
+      import_path6.default.join(project.rootDir, "_.d.ts"),
+      host.getCompilationSettings(),
+      host
+    );
+    const markoTypesFile = (resolvedTypeReferenceDirective == null ? void 0 : resolvedTypeReferenceDirective.resolvedFileName) || defaultMarkoTypesFile;
+    cached = {
+      internalTypesFile,
+      markoTypesFile,
+      markoTypesCode: host.readFile(markoTypesFile, "utf-8") || ""
+    };
+    project.cache.set(getProjectTypeLibs, cached);
+  }
+  return cached;
+}
+
+// src/utils/get-script-lang.ts
+var import_language_tools12 = require("@marko/language-tools");
+function getScriptLang(filename, ts2, host, projectScriptLang) {
+  const configPath = ts2.findConfigFile(
+    filename,
+    host.fileExists.bind(host),
+    "marko.json"
+  );
+  if (configPath) {
+    try {
+      const markoConfig = JSON.parse(
+        host.readFile(configPath, "utf-8") || "{}"
+      );
+      const scriptLang = markoConfig["script-lang"] || markoConfig.scriptLang;
+      if (scriptLang !== void 0) {
+        return scriptLang === import_language_tools12.ScriptLang.ts ? import_language_tools12.ScriptLang.ts : import_language_tools12.ScriptLang.js;
       }
-      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;
+    } catch {
+    }
+  }
+  return /[/\\]node_modules[/\\]/.test(filename) ? import_language_tools12.ScriptLang.js : projectScriptLang;
+}
+
+// src/utils/get-component-filename.ts
+var import_path7 = __toESM(require("path"));
+function getComponentFilename(from, host) {
+  const dir = import_path7.default.dirname(from);
+  const nameNoExt = import_path7.default.basename(from, ".marko");
+  const isEntry = nameNoExt === "index";
+  const componentFull = import_path7.default.join(dir, `${nameNoExt}.component.`);
+  const componentBrowserFull = import_path7.default.join(
+    dir,
+    `${nameNoExt}.component-browser.`
+  );
+  const componentPartial = isEntry ? import_path7.default.join(dir, "component.") : void 0;
+  const componentBrowserPartial = isEntry ? import_path7.default.join(dir, "component-browser.") : void 0;
+  for (const entry of host.readDirectory(dir)) {
+    if (entry !== from && (isEntry && entry.startsWith(componentBrowserPartial) || entry.startsWith(componentPartial)) || entry.startsWith(componentBrowserFull) || entry.startsWith(componentFull)) {
+      return entry;
+    }
+  }
+}
+
+// src/ts-plugin/host.ts
+var markoExt = ".marko";
+var markoExtReg = /\.marko$/;
+var modulePartsReg = /^((?:@(?:[^/]+)\/)?(?:[^/]+))(.*)$/;
+var fsPathReg = /^(?:[./\\]|[A-Z]:)/i;
+function patch(ts2, scriptLang, cache, host) {
+  var _a, _b, _c;
+  const projectTypeLibs = getProjectTypeLibs(
+    getMarkoProject(host.getCurrentDirectory()),
+    ts2,
+    host
+  );
+  const isMarkoTSFile = (fileName) => getScriptLang(fileName, ts2, host, scriptLang) === import_language_tools13.ScriptLang.ts;
+  const getScriptFileNames = host.getScriptFileNames.bind(host);
+  host.getScriptFileNames = () => [
+    .../* @__PURE__ */ new Set([
+      ...getScriptFileNames(),
+      projectTypeLibs.internalTypesFile,
+      projectTypeLibs.markoTypesFile
+    ])
+  ];
+  const getScriptKind = (_a = host.getScriptKind) == null ? void 0 : _a.bind(host);
+  if (getScriptKind) {
+    host.getScriptKind = (fileName) => {
+      return markoExtReg.test(fileName) ? isMarkoTSFile(fileName) ? ts2.ScriptKind.TS : ts2.ScriptKind.JS : getScriptKind(fileName);
+    };
+  }
+  const getScriptSnapshot = host.getScriptSnapshot.bind(host);
+  host.getScriptSnapshot = (filename) => {
+    if (markoExtReg.test(filename)) {
+      let cached = cache.get(filename);
+      if (!cached) {
+        const code = host.readFile(filename, "utf-8") || "";
+        const markoProject = getMarkoProject(import_path8.default.dirname(filename));
+        cached = (0, import_language_tools13.extractScript)({
+          ts: ts2,
+          parsed: (0, import_language_tools13.parse)(code, filename),
+          lookup: markoProject.lookup,
+          scriptLang: getScriptLang(filename, ts2, host, scriptLang),
+          runtimeTypesCode: projectTypeLibs.markoTypesCode,
+          componentFilename: getComponentFilename(filename, host)
+        });
+        cached.snapshot = ts2.ScriptSnapshot.fromString(cached.toString());
+        cache.set(filename, cached);
+      }
+      return cached.snapshot;
+    }
+    return getScriptSnapshot(filename);
+  };
+  const readDirectory2 = (_b = host.readDirectory) == null ? void 0 : _b.bind(host);
+  if (readDirectory2) {
+    host.readDirectory = (path10, extensions, exclude, include, depth) => {
+      return readDirectory2(
+        path10,
+        extensions == null ? void 0 : extensions.concat(markoExt),
+        exclude,
+        include,
+        depth
+      );
+    };
+  }
+  const resolveModuleNames = (_c = host.resolveModuleNames) == null ? void 0 : _c.bind(host);
+  if (resolveModuleNames) {
+    host.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, options, sourceFile) => {
+      const resolvedModules = resolveModuleNames(
+        moduleNames,
+        containingFile,
+        reusedNames,
+        redirectedReference,
+        options,
+        sourceFile
+      );
+      for (let i = resolvedModules.length; i--; ) {
+        const moduleName = moduleNames[i];
+        if (!resolvedModules[i] && markoExtReg.test(moduleName)) {
+          if (fsPathReg.test(moduleName)) {
+            const resolvedFileName = import_path8.default.resolve(
+              containingFile,
+              "..",
+              moduleName
+            );
+            if (host.fileExists(resolvedFileName)) {
+              resolvedModules[i] = {
+                resolvedFileName,
+                extension: isMarkoTSFile(resolvedFileName) ? ts2.Extension.Ts : ts2.Extension.Js,
+                isExternalLibraryImport: false
+              };
+            }
+          } else if (moduleName[0] !== "*") {
+            const [, nodeModuleName, relativeModulePath] = modulePartsReg.exec(moduleName);
+            const { resolvedModule } = ts2.resolveModuleName(
+              `${nodeModuleName}/package.json`,
+              containingFile,
+              options,
+              host
+            );
+            if (resolvedModule) {
+              const resolvedFileName = import_path8.default.join(
+                resolvedModule.resolvedFileName,
+                "..",
+                relativeModulePath
+              );
+              if (host.fileExists(resolvedFileName)) {
+                const isTS = isMarkoTSFile(resolvedFileName);
+                resolvedModules[i] = {
+                  resolvedFileName,
+                  extension: isTS ? ts2.Extension.Ts : ts2.Extension.Js,
+                  isExternalLibraryImport: isTS
+                };
+              }
             }
           }
-          next -= 3;
-          sort(left, next - 3);
-          sort(next + 3, right);
         }
-      })(1, sourceMap.length - 2);
+      }
+      return resolvedModules;
+    };
+  }
+  return host;
+}
+
+// src/service/script/index.ts
+var IGNORE_DIAG_REG = /^(?:Expression|Identifier|['"][^\w]['"]) expected.$/;
+var extractCache = /* @__PURE__ */ new Map();
+var snapshotCache = /* @__PURE__ */ new Map();
+var markoFileReg = /\.marko$/;
+var tsTriggerChars = /* @__PURE__ */ new Set([".", '"', "'", "`", "/", "@", "<", "#", " "]);
+var optionalModifierReg = /\boptional\b/;
+var deprecatedModifierReg = /\bdeprecated\b/;
+var colorModifierReg = /\bcolor\b/;
+var localInternalsPrefix = "__marko_internal_";
+var ScriptService = {
+  commands: {
+    "$/showScriptOutput": async (uri) => {
+      const doc = get(uri);
+      if ((doc == null ? void 0 : doc.languageId) !== "marko")
+        return;
+      const filename = getFSPath(doc);
+      if (!filename)
+        return;
+      const project = getTSProject(filename);
+      const extracted = processScript(doc, project);
+      const lang = getScriptLang(
+        filename,
+        import_tsserverlibrary.default,
+        project.host,
+        project.markoScriptLang
+      );
+      const generated = extracted.toString();
+      const content = (() => {
+        try {
+          return prettier2.format(generated, {
+            parser: lang === import_language_tools14.ScriptLang.ts ? "typescript" : "babel"
+          });
+        } catch {
+          return generated;
+        }
+      })();
       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;
-            }
+        language: lang === import_language_tools14.ScriptLang.ts ? "typescript" : "javascript",
+        content
+      };
+    }
+  },
+  async initialize() {
+    onConfigChange(() => {
+      snapshotCache.clear();
+    });
+    onFileChange((doc) => {
+      if (doc) {
+        const filename = getFSPath(doc);
+        extractCache.delete(filename);
+        snapshotCache.delete(filename);
+      } else {
+        extractCache.clear();
+        snapshotCache.clear();
+      }
+    });
+  },
+  async doComplete(doc, params) {
+    var _a;
+    const fileName = getFSPath(doc);
+    if (!fileName)
+      return;
+    const project = getTSProject(fileName);
+    const extracted = processScript(doc, project);
+    const sourceOffset = doc.offsetAt(params.position);
+    const generatedOffset = extracted.generatedOffsetAt(sourceOffset);
+    if (generatedOffset === void 0)
+      return;
+    const completions = project.service.getCompletionsAtPosition(
+      fileName,
+      generatedOffset,
+      {
+        ...await getPreferences(project.markoScriptLang),
+        ...params.context,
+        triggerCharacter: getTSTriggerChar((_a = params.context) == null ? void 0 : _a.triggerCharacter)
+      }
+    );
+    if (!(completions == null ? void 0 : completions.entries.length))
+      return;
+    const result = [];
+    for (const completion of completions.entries) {
+      let { name: label, insertText, sortText } = completion;
+      if (label.startsWith(localInternalsPrefix))
+        continue;
+      const { replacementSpan } = completion;
+      let textEdit;
+      let detail;
+      let kind;
+      let tags;
+      let labelDetails;
+      let source = completion.source;
+      if (source && completion.hasAction) {
+        if (source[0] === ".") {
+          source = import_path9.default.resolve(fileName, "..", source);
+        }
+        detail = (0, import_relative_import_path.relativeImportPath)(fileName, source);
+        sortText = `\uFFFF${sortText}`;
+      } else if (completion.sourceDisplay) {
+        const description = import_tsserverlibrary.default.displayPartsToString(completion.sourceDisplay);
+        if (description !== label) {
+          labelDetails = { description };
+        }
+      }
+      if (completion.kindModifiers) {
+        if (optionalModifierReg.test(completion.kindModifiers)) {
+          insertText = label;
+          label += "?";
+        }
+        if (deprecatedModifierReg.test(completion.kindModifiers)) {
+          tags = [import_vscode_languageserver10.CompletionItemTag.Deprecated];
+        }
+        if (colorModifierReg.test(completion.kindModifiers)) {
+          kind = import_vscode_languageserver10.CompletionItemKind.Color;
+        }
+      }
+      if (replacementSpan) {
+        const sourceRange = sourceLocationAtTextSpan(
+          extracted,
+          replacementSpan
+        );
+        if (sourceRange) {
+          textEdit = {
+            range: sourceRange,
+            newText: insertText || label
+          };
+        } else {
+          continue;
+        }
+      }
+      result.push({
+        tags,
+        label,
+        detail,
+        textEdit,
+        sortText,
+        insertText,
+        labelDetails,
+        filterText: insertText,
+        preselect: completion.isRecommended || void 0,
+        kind: kind || convertCompletionItemKind(completion.kind),
+        insertTextFormat: completion.isSnippet ? import_vscode_languageserver10.InsertTextFormat.Snippet : void 0,
+        data: completion.data && {
+          originalData: completion.data,
+          originalName: completion.name,
+          originalSource: source,
+          generatedOffset,
+          fileName
+        }
+      });
+    }
+    return {
+      isIncomplete: true,
+      items: result
+    };
+  },
+  async doCompletionResolve(item) {
+    const { data } = item;
+    if (!data)
+      return;
+    const { fileName } = data;
+    if (!fileName)
+      return;
+    const doc = get(filenameToURI(fileName));
+    if (!doc)
+      return;
+    const project = getTSProject(fileName);
+    const detail = project.service.getCompletionEntryDetails(
+      fileName,
+      data.generatedOffset,
+      data.originalName,
+      {},
+      data.originalSource,
+      await getPreferences(project.markoScriptLang),
+      data.originalData
+    );
+    if (!(detail == null ? void 0 : detail.codeActions))
+      return;
+    const extracted = processScript(doc, project);
+    const textEdits = item.additionalTextEdits = item.additionalTextEdits || [];
+    for (const action of detail.codeActions) {
+      for (const change of action.changes) {
+        if (change.fileName !== fileName)
+          continue;
+        for (const { span, newText } of change.textChanges) {
+          const sourceRange = /^\s*(?:import|export) /.test(newText) ? (
+            // Ensure import inserts are always in the program root.
+            // TODO: this could probably be updated to more closely reflect
+            // where typescript wants to put the import/export.
+            START_LOCATION
+          ) : sourceLocationAtTextSpan(extracted, span);
+          if (sourceRange) {
+            textEdits.push({
+              newText,
+              range: sourceRange
+            });
           }
-          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;
-            }
+        }
+      }
+    }
+    return item;
+  },
+  findDefinition(doc, params) {
+    const fileName = getFSPath(doc);
+    if (!fileName)
+      return;
+    const project = getTSProject(fileName);
+    const extracted = processScript(doc, project);
+    const sourceOffset = doc.offsetAt(params.position);
+    const generatedOffset = extracted.generatedOffsetAt(sourceOffset);
+    if (generatedOffset === void 0)
+      return;
+    const boundary = project.service.getDefinitionAndBoundSpan(
+      fileName,
+      generatedOffset
+    );
+    if (!(boundary == null ? void 0 : boundary.definitions))
+      return;
+    const originSelectionRange = sourceLocationAtTextSpan(
+      extracted,
+      boundary.textSpan
+    );
+    let result;
+    for (const def of boundary.definitions) {
+      const targetUri = filenameToURI(def.fileName);
+      const defDoc = get(targetUri);
+      if (!defDoc)
+        continue;
+      let link;
+      if (markoFileReg.test(targetUri)) {
+        const extracted2 = processScript(defDoc, project);
+        const targetSelectionRange = sourceLocationAtTextSpan(extracted2, def.textSpan) || START_LOCATION;
+        const targetRange = def.contextSpan && sourceLocationAtTextSpan(extracted2, def.contextSpan) || START_LOCATION;
+        link = {
+          targetUri,
+          targetRange,
+          targetSelectionRange,
+          originSelectionRange
+        };
+      } else {
+        link = {
+          targetUri,
+          targetRange: def.contextSpan ? docLocationAtTextSpan(defDoc, def.contextSpan) : START_LOCATION,
+          targetSelectionRange: docLocationAtTextSpan(defDoc, def.textSpan),
+          originSelectionRange
+        };
+      }
+      if (link) {
+        if (result) {
+          if (Array.isArray(result)) {
+            result.push(link);
+          } else {
+            result = [result, link];
           }
-          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);
+        } else {
+          result = link;
         }
-      };
+      }
     }
-  };
+    return result;
+  },
+  doHover(doc, params) {
+    const fileName = getFSPath(doc);
+    if (!fileName)
+      return;
+    const project = getTSProject(fileName);
+    const extracted = processScript(doc, project);
+    const sourceOffset = doc.offsetAt(params.position);
+    const generatedOffset = extracted.generatedOffsetAt(sourceOffset);
+    if (generatedOffset === void 0)
+      return;
+    const quickInfo = project.service.getQuickInfoAtPosition(
+      fileName,
+      generatedOffset
+    );
+    if (!quickInfo)
+      return;
+    const sourceRange = sourceLocationAtTextSpan(extracted, quickInfo.textSpan);
+    if (!sourceRange)
+      return;
+    let contents = "";
+    const displayParts = import_tsserverlibrary.default.displayPartsToString(quickInfo.displayParts);
+    if (displayParts) {
+      contents += `\`\`\`typescript
+${displayParts}
+\`\`\``;
+    }
+    const documentation = printDocumentation(
+      quickInfo.documentation,
+      quickInfo.tags
+    );
+    if (documentation) {
+      contents += `
+---
+${documentation}`;
+    }
+    return {
+      range: sourceRange,
+      contents
+    };
+  },
+  doRename(doc, params) {
+    const fileName = getFSPath(doc);
+    if (!fileName)
+      return;
+    const project = getTSProject(fileName);
+    const extracted = processScript(doc, project);
+    const sourceOffset = doc.offsetAt(params.position);
+    const generatedOffset = extracted.generatedOffsetAt(sourceOffset);
+    if (generatedOffset === void 0)
+      return;
+    const renameLocations = project.service.findRenameLocations(
+      fileName,
+      generatedOffset,
+      false,
+      false,
+      false
+    );
+    if (!renameLocations)
+      return;
+    const changes = {};
+    for (const rename of renameLocations) {
+      const renameURI = filenameToURI(rename.fileName);
+      const renameDoc = get(renameURI);
+      let edit;
+      if (!renameDoc)
+        continue;
+      if (markoFileReg.test(renameURI)) {
+        const extracted2 = processScript(renameDoc, project);
+        const sourceRange = sourceLocationAtTextSpan(
+          extracted2,
+          rename.textSpan
+        );
+        if (sourceRange) {
+          edit = {
+            newText: params.newName,
+            range: sourceRange
+          };
+        }
+      } else {
+        edit = {
+          newText: params.newName,
+          range: docLocationAtTextSpan(renameDoc, rename.textSpan)
+        };
+      }
+      if (edit) {
+        if (changes[renameURI]) {
+          changes[renameURI].push(edit);
+        } else {
+          changes[renameURI] = [edit];
+        }
+      }
+    }
+    return {
+      changes
+    };
+  },
+  doValidate(doc) {
+    const fileName = getFSPath(doc);
+    if (!fileName)
+      return;
+    const project = getTSProject(fileName);
+    const extracted = processScript(doc, project);
+    let results;
+    for (const tsDiag of project.service.getSuggestionDiagnostics(fileName)) {
+      addDiag(tsDiag);
+    }
+    for (const tsDiag of project.service.getSyntacticDiagnostics(fileName)) {
+      addDiag(tsDiag);
+    }
+    for (const tsDiag of project.service.getSemanticDiagnostics(fileName)) {
+      addDiag(tsDiag);
+    }
+    return results;
+    function addDiag(tsDiag) {
+      const diag = convertDiag(extracted, tsDiag);
+      if (diag && !IGNORE_DIAG_REG.test(diag.message)) {
+        if (results) {
+          results.push(diag);
+        } else {
+          results = [diag];
+        }
+      }
+    }
+  }
+};
+function processScript(doc, tsProject) {
+  return processDoc(doc, ({ parsed, filename, project: markoProject }) => {
+    var _a;
+    const { lookup } = markoProject;
+    const { host, markoScriptLang } = tsProject;
+    return (0, import_language_tools14.extractScript)({
+      ts: import_tsserverlibrary.default,
+      parsed,
+      lookup,
+      scriptLang: getScriptLang(filename, import_tsserverlibrary.default, host, markoScriptLang),
+      runtimeTypesCode: (_a = getProjectTypeLibs(markoProject, import_tsserverlibrary.default, host)) == null ? void 0 : _a.markoTypesCode,
+      componentFilename: getComponentFilename(filename, host)
+    });
+  });
 }
-
-// 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";
+function sourceLocationAtTextSpan(extracted, { start, length }) {
+  if (start === 0 && length === 0)
+    return START_LOCATION;
+  return extracted.sourceLocationAt(start, start + length);
+}
+function docLocationAtTextSpan(doc, { start, length }) {
+  return {
+    start: doc.positionAt(start),
+    end: doc.positionAt(start + length)
   };
-  const visit = (node) => {
-    var _a, _b;
-    switch (node.type) {
-      case 14 /* AttrTag */:
-        if (node.body) {
-          for (const child of node.body) {
-            visit(child);
-          }
-        }
-        break;
-      case 1 /* Tag */:
-        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;
-          }
+}
+function getTSProject(docFsPath) {
+  var _a;
+  let configPath;
+  let markoScriptLang = import_language_tools14.ScriptLang.js;
+  if (docFsPath) {
+    configPath = import_tsserverlibrary.default.findConfigFile(
+      docFsPath,
+      import_tsserverlibrary.default.sys.fileExists,
+      "tsconfig.json"
+    );
+    if (configPath) {
+      markoScriptLang = import_language_tools14.ScriptLang.ts;
+    } else {
+      configPath = import_tsserverlibrary.default.findConfigFile(
+        docFsPath,
+        import_tsserverlibrary.default.sys.fileExists,
+        "jsconfig.json"
+      );
+    }
+  }
+  const rootDir = configPath && import_path9.default.dirname(configPath) || process.cwd();
+  const markoProject = getMarkoProject(configPath && rootDir);
+  let projectCache = markoProject.cache.get(getTSProject);
+  let cached;
+  if (projectCache) {
+    cached = projectCache.get(rootDir);
+    if (cached)
+      return cached;
+  } else {
+    projectCache = /* @__PURE__ */ new Map();
+    markoProject.cache.set(getTSProject, projectCache);
+  }
+  const { fileNames, options, projectReferences } = import_tsserverlibrary.default.parseJsonConfigFileContent(
+    configPath && import_tsserverlibrary.default.readConfigFile(configPath, import_tsserverlibrary.default.sys.readFile).config || {
+      compilerOptions: { lib: ["dom", "node", "esnext"] }
+    },
+    import_tsserverlibrary.default.sys,
+    rootDir,
+    void 0,
+    configPath,
+    void 0,
+    [
+      {
+        extension: ".marko",
+        isMixedContent: false,
+        scriptKind: import_tsserverlibrary.default.ScriptKind.Deferred
+      }
+    ]
+  );
+  const potentialGlobalFiles = new Set(
+    fileNames.filter((file) => /\.[cm]?ts$/.test(file))
+  );
+  options.rootDir ??= rootDir;
+  options.module = import_tsserverlibrary.default.ModuleKind.ESNext;
+  options.moduleResolution = import_tsserverlibrary.default.ModuleResolutionKind.NodeJs;
+  options.noEmit = options.allowJs = options.declaration = options.skipLibCheck = options.isolatedModules = options.resolveJsonModule = options.skipDefaultLibCheck = options.allowNonTsExtensions = true;
+  const tsPkgFile = configPath && ((_a = import_tsserverlibrary.default.resolveModuleName("typescript/package.json", configPath, options, import_tsserverlibrary.default.sys).resolvedModule) == null ? void 0 : _a.resolvedFileName);
+  const defaultLibFile = import_path9.default.join(
+    tsPkgFile ? import_path9.default.join(tsPkgFile, "../lib") : __dirname,
+    import_tsserverlibrary.default.getDefaultLibFileName(options)
+  );
+  const host = patch(
+    import_tsserverlibrary.default,
+    markoScriptLang,
+    extractCache,
+    {
+      getNewLine() {
+        return import_tsserverlibrary.default.sys.newLine;
+      },
+      useCaseSensitiveFileNames() {
+        return import_tsserverlibrary.default.sys.useCaseSensitiveFileNames;
+      },
+      getCompilationSettings() {
+        return options;
+      },
+      getCurrentDirectory() {
+        return options.rootDir;
+      },
+      getProjectVersion() {
+        return projectVersion.toString(32);
+      },
+      getDefaultLibFileName() {
+        return defaultLibFile;
+      },
+      getProjectReferences() {
+        return projectReferences;
+      },
+      resolveModuleNames(moduleNames, containingFile) {
+        return moduleNames.map((moduleName) => {
+          return import_tsserverlibrary.default.resolveModuleName(moduleName, containingFile, options, host).resolvedModule;
+        });
+      },
+      readDirectory: import_tsserverlibrary.default.sys.readDirectory,
+      readFile: (filename) => {
+        var _a2;
+        return (_a2 = get(filenameToURI(filename))) == null ? void 0 : _a2.getText();
+      },
+      fileExists: (filename) => exists(filenameToURI(filename)),
+      getScriptFileNames() {
+        const result = new Set(potentialGlobalFiles);
+        for (const doc of getAllOpen()) {
+          const { scheme, fsPath } = import_vscode_uri6.URI.parse(doc.uri);
+          if (scheme === "file")
+            result.add(fsPath);
         }
-        if (node.body) {
-          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 {
-            for (const child of node.body) {
-              visit(child);
-            }
-          }
+        return [...result];
+      },
+      getScriptVersion(filename) {
+        var _a2;
+        return `${((_a2 = get(filenameToURI(filename))) == null ? void 0 : _a2.version) ?? -1}`;
+      },
+      getScriptKind(filename) {
+        switch (import_path9.default.extname(filename)) {
+          case import_tsserverlibrary.default.Extension.Js:
+            return import_tsserverlibrary.default.ScriptKind.JS;
+          case import_tsserverlibrary.default.Extension.Jsx:
+            return import_tsserverlibrary.default.ScriptKind.JSX;
+          case import_tsserverlibrary.default.Extension.Ts:
+            return import_tsserverlibrary.default.ScriptKind.TS;
+          case import_tsserverlibrary.default.Extension.Tsx:
+            return import_tsserverlibrary.default.ScriptKind.TSX;
+          case import_tsserverlibrary.default.Extension.Json:
+            return import_tsserverlibrary.default.ScriptKind.JSON;
+          default:
+            return import_tsserverlibrary.default.ScriptKind.Unknown;
         }
-        if (node.attrs) {
-          for (const attr of node.attrs) {
-            if (attr.type === 8 /* AttrNamed */ && ((_a = attr.value) == null ? void 0 : _a.type) === 11 /* AttrValue */ && /^['"]$/.test(code[attr.value.value.start])) {
-              const name = read(attr.name);
-              if (name === "#style" || name === "style" && node.nameText && name === "style" && ((_b = lookup.getTag(node.nameText)) == null ? void 0 : _b.html)) {
-                getExtractor("css").write`:root{${{
-                  start: attr.value.value.start + 1,
-                  end: attr.value.value.end - 1
-                }}}`;
-              }
-            }
-          }
+      },
+      getScriptSnapshot(filename) {
+        let snapshot = snapshotCache.get(filename);
+        if (!snapshot) {
+          const doc = get(filenameToURI(filename));
+          if (!doc)
+            return;
+          snapshot = import_tsserverlibrary.default.ScriptSnapshot.fromString(doc.getText());
+          snapshotCache.set(filename, snapshot);
         }
-        break;
+        return snapshot;
+      }
     }
+  );
+  const tsProject = {
+    host,
+    rootDir: options.rootDir,
+    service: import_tsserverlibrary.default.createLanguageService(host),
+    markoProject,
+    markoScriptLang,
+    markoProjectTypeLibs: getProjectTypeLibs(markoProject, import_tsserverlibrary.default, host)
   };
-  for (const node of program.body)
-    visit(node);
-  const resultsByExt = {};
-  for (const ext in extractorsByExt) {
-    resultsByExt[ext] = extractorsByExt[ext].end();
+  projectCache.set(rootDir, tsProject);
+  return tsProject;
+}
+function filenameToURI(filename) {
+  return import_vscode_uri6.URI.file(filename).toString();
+}
+async function getPreferences(scriptLang) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const configName = scriptLang === import_language_tools14.ScriptLang.js ? "javascript" : "typescript";
+  const [preferencesConfig, suggestConfig, inlayHintsConfig] = await Promise.all([
+    getConfig(`${configName}.preferences`),
+    getConfig(`${configName}.suggest`),
+    getConfig(`${configName}.inlayHints`)
+  ]);
+  return {
+    disableSuggestions: suggestConfig.enabled === false,
+    quotePreference: preferencesConfig.quoteStyle || "auto",
+    includeCompletionsForModuleExports: suggestConfig.autoImports ?? true,
+    includeCompletionsForImportStatements: suggestConfig.includeCompletionsForImportStatements ?? true,
+    includeCompletionsWithSnippetText: suggestConfig.includeCompletionsWithSnippetText ?? true,
+    includeAutomaticOptionalChainCompletions: suggestConfig.includeAutomaticOptionalChainCompletions ?? true,
+    includeCompletionsWithInsertText: true,
+    includeCompletionsWithClassMemberSnippets: ((_a = suggestConfig.classMemberSnippets) == null ? void 0 : _a.enabled) ?? true,
+    includeCompletionsWithObjectLiteralMethodSnippets: ((_b = suggestConfig.objectLiteralMethodSnippets) == null ? void 0 : _b.enabled) ?? true,
+    useLabelDetailsInCompletionEntries: true,
+    allowIncompleteCompletions: true,
+    importModuleSpecifierPreference: preferencesConfig.importModuleSpecifierPreference,
+    importModuleSpecifierEnding: preferencesConfig.importModuleSpecifierEnding || "auto",
+    allowTextChangesInNewFiles: true,
+    providePrefixAndSuffixTextForRename: true,
+    includePackageJsonAutoImports: preferencesConfig.includePackageJsonAutoImports ?? true,
+    provideRefactorNotApplicableReason: true,
+    jsxAttributeCompletionStyle: preferencesConfig.jsxAttributeCompletionStyle ?? "auto",
+    includeInlayParameterNameHints: ((_c = inlayHintsConfig.parameterNames) == null ? void 0 : _c.enabled) ?? "none",
+    includeInlayParameterNameHintsWhenArgumentMatchesName: !((_d = inlayHintsConfig.parameterNames) == null ? void 0 : _d.suppressWhenArgumentMatchesName),
+    includeInlayFunctionParameterTypeHints: ((_e = inlayHintsConfig.parameterTypes) == null ? void 0 : _e.enabled) ?? true,
+    includeInlayVariableTypeHints: ((_f = inlayHintsConfig.variableTypes) == null ? void 0 : _f.enabled) ?? true,
+    includeInlayPropertyDeclarationTypeHints: ((_g = inlayHintsConfig.propertyDeclarationTypes) == null ? void 0 : _g.enabled) ?? true,
+    includeInlayFunctionLikeReturnTypeHints: ((_h = inlayHintsConfig.functionLikeReturnTypes) == null ? void 0 : _h.enabled) ?? true,
+    includeInlayEnumMemberValueHints: ((_i = inlayHintsConfig.enumMemberValues) == null ? void 0 : _i.enabled) ?? true
+  };
+}
+function printDocumentation(docs2, tags) {
+  let result = "";
+  if (docs2) {
+    result += import_tsserverlibrary.default.displayPartsToString(docs2);
+  }
+  if (tags) {
+    for (const tag of tags) {
+      const text = import_tsserverlibrary.default.displayPartsToString(tag.text);
+      result += `*@${tag.name}*${text ? /\n/.test(text) ? `
+${text}` : `- ${text}` : ""}`;
+    }
+  }
+  return result;
+}
+function convertDiag(extracted, tsDiag) {
+  const sourceRange = tsDiag.start === void 0 ? START_LOCATION : sourceLocationAtTextSpan(extracted, tsDiag);
+  if (sourceRange) {
+    return {
+      range: sourceRange,
+      source: "script",
+      code: tsDiag.code,
+      tags: convertDiagTags(tsDiag),
+      severity: convertDiagSeverity(tsDiag),
+      message: import_tsserverlibrary.default.flattenDiagnosticMessageText(tsDiag.messageText, "\n")
+    };
+  }
+}
+function convertDiagSeverity(tsDiag) {
+  switch (tsDiag.category) {
+    case import_tsserverlibrary.default.DiagnosticCategory.Error:
+      return import_vscode_languageserver10.DiagnosticSeverity.Error;
+    case import_tsserverlibrary.default.DiagnosticCategory.Warning:
+      return import_vscode_languageserver10.DiagnosticSeverity.Warning;
+    case import_tsserverlibrary.default.DiagnosticCategory.Suggestion:
+      return import_vscode_languageserver10.DiagnosticSeverity.Hint;
+    default:
+      return import_vscode_languageserver10.DiagnosticSeverity.Information;
+  }
+}
+function convertDiagTags(tsDiag) {
+  let tags;
+  if (tsDiag.reportsDeprecated) {
+    tags = [import_vscode_languageserver10.DiagnosticTag.Deprecated];
+  }
+  if (tsDiag.reportsUnnecessary) {
+    if (tags)
+      tags.push(import_vscode_languageserver10.DiagnosticTag.Unnecessary);
+    else
+      tags = [import_vscode_languageserver10.DiagnosticTag.Unnecessary];
+  }
+  return tags;
+}
+function convertCompletionItemKind(kind) {
+  switch (kind) {
+    case import_tsserverlibrary.default.ScriptElementKind.warning:
+    case import_tsserverlibrary.default.ScriptElementKind.linkText:
+      return import_vscode_languageserver10.CompletionItemKind.Text;
+    case import_tsserverlibrary.default.ScriptElementKind.keyword:
+    case import_tsserverlibrary.default.ScriptElementKind.primitiveType:
+      return import_vscode_languageserver10.CompletionItemKind.Keyword;
+    case import_tsserverlibrary.default.ScriptElementKind.scriptElement:
+      return import_vscode_languageserver10.CompletionItemKind.File;
+    case import_tsserverlibrary.default.ScriptElementKind.directory:
+      return import_vscode_languageserver10.CompletionItemKind.Folder;
+    case import_tsserverlibrary.default.ScriptElementKind.label:
+    case import_tsserverlibrary.default.ScriptElementKind.string:
+      return import_vscode_languageserver10.CompletionItemKind.Constant;
+    case import_tsserverlibrary.default.ScriptElementKind.moduleElement:
+    case import_tsserverlibrary.default.ScriptElementKind.externalModuleName:
+      return import_vscode_languageserver10.CompletionItemKind.Module;
+    case import_tsserverlibrary.default.ScriptElementKind.typeElement:
+    case import_tsserverlibrary.default.ScriptElementKind.classElement:
+    case import_tsserverlibrary.default.ScriptElementKind.localClassElement:
+      return import_vscode_languageserver10.CompletionItemKind.Class;
+    case import_tsserverlibrary.default.ScriptElementKind.interfaceElement:
+      return import_vscode_languageserver10.CompletionItemKind.Interface;
+    case import_tsserverlibrary.default.ScriptElementKind.enumElement:
+      return import_vscode_languageserver10.CompletionItemKind.Enum;
+    case import_tsserverlibrary.default.ScriptElementKind.enumMemberElement:
+      return import_vscode_languageserver10.CompletionItemKind.EnumMember;
+    case import_tsserverlibrary.default.ScriptElementKind.alias:
+    case import_tsserverlibrary.default.ScriptElementKind.letElement:
+    case import_tsserverlibrary.default.ScriptElementKind.constElement:
+    case import_tsserverlibrary.default.ScriptElementKind.variableElement:
+    case import_tsserverlibrary.default.ScriptElementKind.parameterElement:
+    case import_tsserverlibrary.default.ScriptElementKind.localVariableElement:
+      return import_vscode_languageserver10.CompletionItemKind.Variable;
+    case import_tsserverlibrary.default.ScriptElementKind.functionElement:
+    case import_tsserverlibrary.default.ScriptElementKind.localFunctionElement:
+      return import_vscode_languageserver10.CompletionItemKind.Function;
+    case import_tsserverlibrary.default.ScriptElementKind.callSignatureElement:
+    case import_tsserverlibrary.default.ScriptElementKind.memberFunctionElement:
+    case import_tsserverlibrary.default.ScriptElementKind.indexSignatureElement:
+    case import_tsserverlibrary.default.ScriptElementKind.constructSignatureElement:
+      return import_vscode_languageserver10.CompletionItemKind.Method;
+    case import_tsserverlibrary.default.ScriptElementKind.memberGetAccessorElement:
+    case import_tsserverlibrary.default.ScriptElementKind.memberSetAccessorElement:
+    case import_tsserverlibrary.default.ScriptElementKind.memberVariableElement:
+      return import_vscode_languageserver10.CompletionItemKind.Field;
+    case import_tsserverlibrary.default.ScriptElementKind.constructorImplementationElement:
+      return import_vscode_languageserver10.CompletionItemKind.Constructor;
+    case import_tsserverlibrary.default.ScriptElementKind.typeParameterElement:
+      return import_vscode_languageserver10.CompletionItemKind.TypeParameter;
+    case import_tsserverlibrary.default.ScriptElementKind.link:
+    case import_tsserverlibrary.default.ScriptElementKind.linkName:
+      return import_vscode_languageserver10.CompletionItemKind.Reference;
+    default:
+      return import_vscode_languageserver10.CompletionItemKind.Property;
   }
-  return resultsByExt;
+}
+function getTSTriggerChar(char) {
+  if (char && tsTriggerChars.has(char))
+    return char;
 }
 
-// src/service/stylesheet/index.ts
-var cache3 = /* @__PURE__ */ new WeakMap();
+// src/service/style/index.ts
+var import_vscode_css_languageservice2 = require("vscode-css-languageservice");
+var import_vscode_languageserver11 = require("vscode-languageserver");
+var import_vscode_languageserver_textdocument2 = require("vscode-languageserver-textdocument");
+var import_language_tools15 = require("@marko/language-tools");
 var services = {
-  css: import_vscode_css_languageservice2.getCSSLanguageService,
-  less: import_vscode_css_languageservice2.getLESSLanguageService,
-  scss: import_vscode_css_languageservice2.getSCSSLanguageService
+  ".css": import_vscode_css_languageservice2.getCSSLanguageService,
+  ".less": import_vscode_css_languageservice2.getLESSLanguageService,
+  ".scss": import_vscode_css_languageservice2.getSCSSLanguageService
 };
 var clientCapabilities;
 var StyleSheetService = {
@@ -1709,70 +2176,58 @@ var StyleSheetService = {
     clientCapabilities = params.capabilities;
   },
   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)
+    for (const style of processStyle(doc)) {
+      const generatedPos = style.extracted.generatedPositionAt(sourceOffset);
+      if (generatedPos === void 0)
         continue;
-      const { service: service2, virtualDoc } = info;
-      const result = await service2.doComplete2(
-        virtualDoc,
-        virtualDoc.positionAt(generatedOffset),
-        info.parsed,
+      const result = await style.service.doComplete2(
+        style.virtualDoc,
+        generatedPos,
+        style.parsed,
         { resolveReference: resolveUrl }
       );
       if (result.itemDefaults) {
         const { editRange } = result.itemDefaults;
         if (editRange) {
           if ("start" in editRange) {
-            result.itemDefaults.editRange = getSourceRange(
-              doc,
-              info,
-              editRange
-            );
+            result.itemDefaults.editRange = getSourceRange(style, editRange);
           } else {
-            editRange.insert = getSourceRange(doc, info, editRange.insert);
-            editRange.replace = getSourceRange(doc, info, editRange.replace);
+            editRange.insert = getSourceRange(style, editRange.insert);
+            editRange.replace = getSourceRange(style, editRange.replace);
           }
         }
       }
       for (const item of result.items) {
         if (item.textEdit) {
-          item.textEdit = getSourceInsertReplaceEdit(doc, info, item.textEdit);
+          item.textEdit = getSourceInsertReplaceEdit(style, item.textEdit);
         }
         if (item.additionalTextEdits) {
           item.additionalTextEdits = getSourceEdits(
-            doc,
-            info,
+            style,
             item.additionalTextEdits
           );
         }
       }
       return result;
     }
-    return import_vscode_languageserver14.CompletionList.create([], true);
   },
   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)
+    for (const style of processStyle(doc)) {
+      const generatedPos = style.extracted.generatedPositionAt(sourceOffset);
+      if (generatedPos === void 0)
         continue;
-      const { service: service2, virtualDoc } = info;
-      const result = service2.findDefinition(
-        virtualDoc,
-        virtualDoc.positionAt(generatedOffset),
-        info.parsed
+      const result = style.service.findDefinition(
+        style.virtualDoc,
+        generatedPos,
+        style.parsed
       );
       if (result) {
-        const range = getSourceRange(doc, info, result.range);
-        if (range) {
+        const sourceRange = getSourceRange(style, result.range);
+        if (sourceRange) {
           return {
-            range,
+            range: sourceRange,
             uri: doc.uri
           };
         }
@@ -1781,24 +2236,21 @@ var StyleSheetService = {
     }
   },
   findReferences(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)
+    for (const style of processStyle(doc)) {
+      const generatedPos = style.extracted.generatedPositionAt(sourceOffset);
+      if (generatedPos === void 0)
         continue;
-      const { service: service2, virtualDoc } = info;
       const result = [];
-      for (const location of service2.findReferences(
-        virtualDoc,
-        virtualDoc.positionAt(generatedOffset),
-        info.parsed
+      for (const location of style.service.findReferences(
+        style.virtualDoc,
+        generatedPos,
+        style.parsed
       )) {
-        const range = getSourceRange(doc, info, location.range);
-        if (range) {
+        const sourceRange = getSourceRange(style, location.range);
+        if (sourceRange) {
           result.push({
-            range,
+            range: sourceRange,
             uri: location.uri
           });
         }
@@ -1807,25 +2259,22 @@ var StyleSheetService = {
     }
   },
   findDocumentSymbols(doc) {
-    const infoByExt = getStyleSheetInfo(doc);
     const result = [];
-    for (const ext in infoByExt) {
-      const info = infoByExt[ext];
-      const { service: service2, virtualDoc } = info;
-      for (const symbol of service2.findDocumentSymbols(
-        virtualDoc,
-        info.parsed
+    for (const extracted of processStyle(doc)) {
+      for (const symbol of extracted.service.findDocumentSymbols(
+        extracted.virtualDoc,
+        extracted.parsed
       )) {
         if (symbol.location.uri === doc.uri) {
-          const range = getSourceRange(doc, info, symbol.location.range);
-          if (range) {
+          const sourceRange = getSourceRange(extracted, symbol.location.range);
+          if (sourceRange) {
             result.push({
               kind: symbol.kind,
               name: symbol.name,
               tags: symbol.tags,
               deprecated: symbol.deprecated,
               containerName: symbol.containerName,
-              location: { uri: doc.uri, range }
+              location: { uri: doc.uri, range: sourceRange }
             });
           }
         } else {
@@ -1836,20 +2285,17 @@ var StyleSheetService = {
     return result.length ? result : void 0;
   },
   async findDocumentLinks(doc) {
-    const infoByExt = getStyleSheetInfo(doc);
     const result = [];
-    for (const ext in infoByExt) {
-      const info = infoByExt[ext];
-      const { service: service2, virtualDoc } = info;
-      for (const link of await service2.findDocumentLinks2(
-        virtualDoc,
-        info.parsed,
+    for (const extracted of processStyle(doc)) {
+      for (const link of await extracted.service.findDocumentLinks2(
+        extracted.virtualDoc,
+        extracted.parsed,
         { resolveReference: resolveUrl }
       )) {
-        const range = getSourceRange(doc, info, link.range);
-        if (range) {
+        const sourceRange = getSourceRange(extracted, link.range);
+        if (sourceRange) {
           result.push({
-            range,
+            range: sourceRange,
             target: link.target,
             tooltip: link.tooltip,
             data: link.data
@@ -1860,24 +2306,21 @@ var StyleSheetService = {
     return result.length ? result : void 0;
   },
   findDocumentHighlights(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)
+    for (const style of processStyle(doc)) {
+      const generatedPos = style.extracted.generatedPositionAt(sourceOffset);
+      if (generatedPos === void 0)
         continue;
-      const { service: service2, virtualDoc } = info;
       const result = [];
-      for (const highlight of service2.findDocumentHighlights(
-        virtualDoc,
-        virtualDoc.positionAt(generatedOffset),
-        info.parsed
+      for (const highlight of style.service.findDocumentHighlights(
+        style.virtualDoc,
+        generatedPos,
+        style.parsed
       )) {
-        const range = getSourceRange(doc, info, highlight.range);
-        if (range) {
+        const sourceRange = getSourceRange(style, highlight.range);
+        if (sourceRange) {
           result.push({
-            range,
+            range: sourceRange,
             kind: highlight.kind
           });
         }
@@ -1886,19 +2329,16 @@ var StyleSheetService = {
     }
   },
   findDocumentColors(doc) {
-    const infoByExt = getStyleSheetInfo(doc);
     const result = [];
-    for (const ext in infoByExt) {
-      const info = infoByExt[ext];
-      const { service: service2, virtualDoc } = info;
-      for (const colorInfo of service2.findDocumentColors(
-        virtualDoc,
-        info.parsed
+    for (const extracted of processStyle(doc)) {
+      for (const colorInfo of extracted.service.findDocumentColors(
+        extracted.virtualDoc,
+        extracted.parsed
       )) {
-        const range = getSourceRange(doc, info, colorInfo.range);
-        if (range) {
+        const sourceRange = getSourceRange(extracted, colorInfo.range);
+        if (sourceRange) {
           result.push({
-            range,
+            range: sourceRange,
             color: colorInfo.color
           });
         }
@@ -1907,31 +2347,19 @@ var StyleSheetService = {
     return result.length ? result : void 0;
   },
   getColorPresentations(doc, params) {
-    const infoByExt = getStyleSheetInfo(doc);
-    const sourceOffset = doc.offsetAt(params.range.start);
-    for (const ext in infoByExt) {
-      const info = infoByExt[ext];
-      const generatedOffsetStart = info.generatedOffsetAt(sourceOffset);
-      if (generatedOffsetStart === void 0)
-        continue;
-      const generatedOffsetEnd = info.generatedOffsetAt(
-        doc.offsetAt(params.range.end)
-      );
-      if (generatedOffsetEnd === void 0)
+    for (const extracted of processStyle(doc)) {
+      const generatedRange = getGeneratedRange(doc, extracted, params.range);
+      if (generatedRange === void 0)
         continue;
-      const { service: service2, virtualDoc } = info;
       const result = [];
-      for (const colorPresentation of service2.getColorPresentations(
-        virtualDoc,
-        info.parsed,
+      for (const colorPresentation of extracted.service.getColorPresentations(
+        extracted.virtualDoc,
+        extracted.parsed,
         params.color,
-        import_vscode_languageserver14.Range.create(
-          virtualDoc.positionAt(generatedOffsetStart),
-          virtualDoc.positionAt(generatedOffsetEnd)
-        )
+        generatedRange
       )) {
-        const textEdit = colorPresentation.textEdit && getSourceEdit(doc, info, colorPresentation.textEdit);
-        const additionalTextEdits = colorPresentation.additionalTextEdits && getSourceEdits(doc, info, colorPresentation.additionalTextEdits);
+        const textEdit = colorPresentation.textEdit && getSourceEdit(extracted, colorPresentation.textEdit);
+        const additionalTextEdits = colorPresentation.additionalTextEdits && getSourceEdits(extracted, colorPresentation.additionalTextEdits);
         if (textEdit || additionalTextEdits) {
           result.push({
             label: colorPresentation.label,
@@ -1944,25 +2372,22 @@ var StyleSheetService = {
     }
   },
   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)
+    for (const style of processStyle(doc)) {
+      const generatedPos = style.extracted.generatedPositionAt(sourceOffset);
+      if (generatedPos === void 0)
         continue;
-      const { service: service2, virtualDoc } = info;
-      const result = service2.doHover(
-        virtualDoc,
-        virtualDoc.positionAt(generatedOffset),
-        info.parsed
+      const result = style.service.doHover(
+        style.virtualDoc,
+        generatedPos,
+        style.parsed
       );
       if (result) {
         if (result.range) {
-          const range = getSourceRange(doc, info, result.range);
-          if (range) {
+          const sourceRange = getSourceRange(style, result.range);
+          if (sourceRange) {
             return {
-              range,
+              range: sourceRange,
               contents: result.contents
             };
           }
@@ -1973,32 +2398,29 @@ var StyleSheetService = {
     }
   },
   async doRename(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);
+    for (const style of processStyle(doc)) {
+      const generatedOffset = style.extracted.generatedOffsetAt(sourceOffset);
       if (generatedOffset === void 0)
         continue;
-      const { service: service2, virtualDoc } = info;
-      const result = service2.doRename(
-        virtualDoc,
-        virtualDoc.positionAt(generatedOffset),
+      const result = style.service.doRename(
+        style.virtualDoc,
+        style.virtualDoc.positionAt(generatedOffset),
         params.newName,
-        info.parsed
+        style.parsed
       );
       if (result.changes) {
         for (const uri in result.changes) {
           if (uri === doc.uri) {
-            result.changes[uri] = getSourceEdits(doc, info, result.changes[uri]) || [];
+            result.changes[uri] = getSourceEdits(style, result.changes[uri]) || [];
           }
         }
       }
       if (result.documentChanges) {
         for (const change of result.documentChanges) {
-          if (import_vscode_languageserver14.TextDocumentEdit.is(change)) {
+          if (import_vscode_languageserver11.TextDocumentEdit.is(change)) {
             if (change.textDocument.uri === doc.uri) {
-              change.edits = getSourceEdits(doc, info, change.edits) || [];
+              change.edits = getSourceEdits(style, change.edits) || [];
             }
           }
         }
@@ -2008,49 +2430,36 @@ var StyleSheetService = {
   },
   doCodeActions(doc, params) {
     var _a;
-    const infoByExt = getStyleSheetInfo(doc);
-    const sourceOffset = doc.offsetAt(params.range.start);
-    for (const ext in infoByExt) {
-      const info = infoByExt[ext];
-      const generatedOffsetStart = info.generatedOffsetAt(sourceOffset);
-      if (generatedOffsetStart === void 0)
-        continue;
-      const generatedOffsetEnd = info.generatedOffsetAt(
-        doc.offsetAt(params.range.end)
-      );
-      if (generatedOffsetEnd === void 0)
+    for (const extracted of processStyle(doc)) {
+      const generatedRange = getGeneratedRange(doc, extracted, params.range);
+      if (generatedRange === void 0)
         continue;
-      const { service: service2, virtualDoc } = info;
-      const result = service2.doCodeActions(
-        virtualDoc,
-        import_vscode_languageserver14.Range.create(
-          virtualDoc.positionAt(generatedOffsetStart),
-          virtualDoc.positionAt(generatedOffsetEnd)
-        ),
+      const result = extracted.service.doCodeActions(
+        extracted.virtualDoc,
+        generatedRange,
         params.context,
-        info.parsed
+        extracted.parsed
       );
       for (const command of result) {
         const edits = (_a = command.arguments) == null ? void 0 : _a[2];
         if (edits && Array.isArray(edits) && isTextEdit(edits[0])) {
-          command.arguments[2] = getSourceEdits(doc, info, edits);
+          command.arguments[2] = getSourceEdits(extracted, edits);
         }
       }
       return result;
     }
   },
   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
+    for (const extracted of processStyle(doc)) {
+      for (const diag of extracted.service.doValidation(
+        extracted.virtualDoc,
+        extracted.parsed
       )) {
-        const range = getSourceRange(doc, info, diag.range);
-        if (range) {
-          diag.range = range;
+        const sourceRange = getSourceRange(extracted, diag.range);
+        if (sourceRange) {
+          diag.source = "style";
+          diag.range = sourceRange;
           result.push(diag);
         }
       }
@@ -2058,123 +2467,112 @@ var StyleSheetService = {
     return result.length ? result : void 0;
   }
 };
-function getSourceEdits(doc, info, edits) {
+function processStyle(doc) {
+  return processDoc(doc, ({ uri, version, parsed, project: { lookup } }) => {
+    var _a;
+    const result = [];
+    for (const [ext, extracted] of (0, import_language_tools15.extractStyle)({
+      parsed,
+      lookup
+    })) {
+      const service2 = (_a = services[ext]) == null ? void 0 : _a.call(services, {
+        fileSystemProvider: file_system_default,
+        clientCapabilities
+      });
+      if (service2) {
+        const virtualDoc = import_vscode_languageserver_textdocument2.TextDocument.create(
+          uri,
+          "css",
+          version,
+          extracted.toString()
+        );
+        result.push({
+          service: service2,
+          extracted,
+          virtualDoc,
+          parsed: service2.parseStylesheet(virtualDoc)
+        });
+      }
+    }
+    return result;
+  });
+}
+function getSourceEdits(extracted, edits) {
   const result = [];
   for (const edit of edits) {
-    const sourceEdit = getSourceEdit(doc, info, edit);
+    const sourceEdit = getSourceEdit(extracted, edit);
     if (sourceEdit) {
       result.push(sourceEdit);
     }
   }
   return result.length ? result : void 0;
 }
-function getSourceEdit(doc, info, textEdit) {
-  const range = getSourceRange(doc, info, textEdit.range);
-  if (range) {
+function getSourceEdit(extracted, textEdit) {
+  const sourceRange = getSourceRange(extracted, textEdit.range);
+  if (sourceRange) {
     return {
       newText: textEdit.newText,
-      range
+      range: sourceRange
     };
   }
 }
-function getSourceInsertReplaceEdit(doc, info, textEdit) {
+function getSourceInsertReplaceEdit(extracted, textEdit) {
   if (isTextEdit(textEdit)) {
-    return getSourceEdit(doc, info, textEdit);
+    return getSourceEdit(extracted, textEdit);
   } else if (textEdit.replace) {
-    const range = getSourceRange(doc, info, textEdit.replace);
-    if (range) {
+    const sourceRange = getSourceRange(extracted, textEdit.replace);
+    if (sourceRange) {
       return {
         newText: textEdit.newText,
-        replace: range
+        replace: sourceRange
       };
     }
   } else {
-    const range = getSourceRange(doc, info, textEdit.insert);
-    if (range) {
+    const sourceRange = getSourceRange(extracted, textEdit.insert);
+    if (sourceRange) {
       return {
         newText: textEdit.newText,
-        insert: range
+        insert: sourceRange
       };
     }
   }
 }
-function getSourceRange(doc, info, range) {
-  const start = info.sourceOffsetAt(info.virtualDoc.offsetAt(range.start));
-  if (start === void 0)
-    return;
-  let end = start;
-  if (range.start.line !== range.end.line || range.start.character !== range.end.character) {
-    end = info.sourceOffsetAt(info.virtualDoc.offsetAt(range.end));
-    if (end === void 0)
-      return;
-  }
-  const pos = doc.positionAt(start);
-  return {
-    start: pos,
-    end: start === end ? pos : doc.positionAt(end)
-  };
+function getSourceRange(style, range) {
+  return style.extracted.sourceLocationAt(
+    style.virtualDoc.offsetAt(range.start),
+    style.virtualDoc.offsetAt(range.end)
+  );
 }
-function getStyleSheetInfo(doc) {
-  var _a;
-  const parsed = parse2(doc);
-  let cached = cache3.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, {
-        fileSystemProvider: file_system_default,
-        clientCapabilities
-      });
-      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)
-      };
-    }
-    cache3.set(parsed, cached);
-  }
-  return cached;
+function getGeneratedRange(doc, style, range) {
+  return style.extracted.generatedLocationAt(
+    doc.offsetAt(range.start),
+    doc.offsetAt(range.end)
+  );
 }
 function isTextEdit(edit) {
   return edit.range !== void 0;
 }
 
 // src/service/index.ts
-var plugins = [marko_default, StyleSheetService];
+var REG_MARKDOWN_CHARS = /[\\`*_{}[\]<>()#+.!|-]/g;
+var plugins = [marko_default, ScriptService, StyleSheetService];
 var service = {
+  commands: Object.assign({}, ...plugins.map(({ commands }) => commands)),
   async initialize(params) {
-    await Promise.all(plugins.map((plugin) => {
-      var _a;
-      return (_a = plugin.initialize) == null ? void 0 : _a.call(plugin, params);
-    }));
+    await Promise.allSettled(
+      plugins.map((plugin) => {
+        var _a;
+        return (_a = plugin.initialize) == null ? void 0 : _a.call(plugin, params);
+      })
+    );
   },
   async doComplete(doc, params, cancel) {
-    let items;
     let isIncomplete = false;
-    try {
-      for (const pending of plugins.map(
-        (plugin) => {
-          var _a;
-          return (_a = plugin.doComplete) == null ? void 0 : _a.call(plugin, doc, params, cancel);
-        }
-      )) {
-        const cur = await pending;
+    const itemsByLabel = /* @__PURE__ */ new Map();
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
+        var _a;
+        const cur = await ((_a = plugin.doComplete) == null ? void 0 : _a.call(plugin, doc, params, cancel));
         if (cancel.isCancellationRequested)
           return;
         if (cur) {
@@ -2183,185 +2581,181 @@ var service = {
             curItems = cur;
           } else {
             curItems = cur.items;
-            isIncomplete || (isIncomplete = cur.isIncomplete);
+            isIncomplete ||= cur.isIncomplete;
+          }
+          for (const item of curItems) {
+            const { label } = item;
+            const existingItem = itemsByLabel.get(label);
+            if (existingItem) {
+              if ((existingItem.sortText || label) < (item.sortText || label)) {
+                itemsByLabel.set(label, item);
+              }
+            } else {
+              itemsByLabel.set(label, item);
+            }
           }
-          items = items ? items.concat(curItems) : curItems;
         }
-      }
-    } catch (err) {
-      isIncomplete = true;
-      displayError(err);
+      })
+    );
+    if (cancel.isCancellationRequested)
+      return;
+    if (itemsByLabel.size) {
+      return { items: [...itemsByLabel.values()], isIncomplete };
     }
-    if (items) {
-      return import_vscode_languageserver15.CompletionList.create(items, isIncomplete);
+  },
+  async doCompletionResolve(item, cancel) {
+    var _a;
+    for (const plugin of plugins) {
+      try {
+        const result = await ((_a = plugin.doCompletionResolve) == null ? void 0 : _a.call(plugin, item, cancel));
+        if (cancel.isCancellationRequested)
+          return;
+        if (result)
+          return result;
+      } catch {
+      }
     }
   },
   async findDefinition(doc, params, cancel) {
     let result;
-    try {
-      for (const pending of plugins.map(
-        (plugin) => {
-          var _a;
-          return (_a = plugin.findDefinition) == null ? void 0 : _a.call(plugin, doc, params, cancel);
-        }
-      )) {
-        const cur = await pending;
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
+        var _a;
+        const cur = await ((_a = plugin.findDefinition) == null ? void 0 : _a.call(plugin, doc, params, cancel));
         if (cancel.isCancellationRequested)
           return;
         if (cur)
           result = (result || []).concat(cur);
-      }
-    } catch (err) {
-      displayError(err);
-    }
+      })
+    );
+    if (cancel.isCancellationRequested)
+      return;
     return result;
   },
   async findReferences(doc, params, cancel) {
     let result;
-    try {
-      for (const pending of plugins.map(
-        (plugin) => {
-          var _a;
-          return (_a = plugin.findReferences) == null ? void 0 : _a.call(plugin, doc, params, cancel);
-        }
-      )) {
-        const cur = await pending;
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
+        var _a;
+        const cur = await ((_a = plugin.findReferences) == null ? void 0 : _a.call(plugin, doc, params, cancel));
         if (cancel.isCancellationRequested)
           return;
         if (cur)
-          result = result ? result.concat(cur) : cur;
-      }
-    } catch (err) {
-      displayError(err);
-    }
+          result = (result || []).concat(cur);
+      })
+    );
+    if (cancel.isCancellationRequested)
+      return;
     return result;
   },
   async findDocumentSymbols(doc, params, cancel) {
     let result;
-    try {
-      for (const pending of plugins.map(
-        (plugin) => {
-          var _a;
-          return (_a = plugin.findDocumentSymbols) == null ? void 0 : _a.call(plugin, doc, params, cancel);
-        }
-      )) {
-        const cur = await pending;
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
+        var _a;
+        const cur = await ((_a = plugin.findDocumentSymbols) == null ? void 0 : _a.call(plugin, doc, params, cancel));
         if (cancel.isCancellationRequested)
           return;
         if (cur)
-          result = result ? result.concat(cur) : cur;
-      }
-    } catch (err) {
-      displayError(err);
-    }
+          result = (result || []).concat(cur);
+      })
+    );
+    if (cancel.isCancellationRequested)
+      return;
     return result;
   },
   async findDocumentLinks(doc, params, cancel) {
     let result;
-    try {
-      for (const pending of plugins.map(
-        (plugin) => {
-          var _a;
-          return (_a = plugin.findDocumentLinks) == null ? void 0 : _a.call(plugin, doc, params, cancel);
-        }
-      )) {
-        const cur = await pending;
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
+        var _a;
+        const cur = await ((_a = plugin.findDocumentLinks) == null ? void 0 : _a.call(plugin, doc, params, cancel));
         if (cancel.isCancellationRequested)
           return;
         if (cur)
-          result = result ? result.concat(cur) : cur;
-      }
-    } catch (err) {
-      displayError(err);
-    }
+          result = (result || []).concat(cur);
+      })
+    );
+    if (cancel.isCancellationRequested)
+      return;
     return result;
   },
   async findDocumentHighlights(doc, params, cancel) {
     let result;
-    try {
-      for (const pending of plugins.map(
-        (plugin) => {
-          var _a;
-          return (_a = plugin.findDocumentHighlights) == null ? void 0 : _a.call(plugin, doc, params, cancel);
-        }
-      )) {
-        const cur = await pending;
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
+        var _a;
+        const cur = await ((_a = plugin.findDocumentHighlights) == null ? void 0 : _a.call(plugin, doc, params, cancel));
         if (cancel.isCancellationRequested)
           return;
         if (cur)
-          result = result ? result.concat(cur) : cur;
-      }
-    } catch (err) {
-      displayError(err);
-    }
+          result = (result || []).concat(cur);
+      })
+    );
+    if (cancel.isCancellationRequested)
+      return;
     return result;
   },
   async findDocumentColors(doc, params, cancel) {
     let result;
-    try {
-      for (const pending of plugins.map(
-        (plugin) => {
-          var _a;
-          return (_a = plugin.findDocumentColors) == null ? void 0 : _a.call(plugin, doc, params, cancel);
-        }
-      )) {
-        const cur = await pending;
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
+        var _a;
+        const cur = await ((_a = plugin.findDocumentColors) == null ? void 0 : _a.call(plugin, doc, params, cancel));
         if (cancel.isCancellationRequested)
           return;
         if (cur)
-          result = result ? result.concat(cur) : cur;
-      }
-    } catch (err) {
-      displayError(err);
-    }
+          result = (result || []).concat(cur);
+      })
+    );
+    if (cancel.isCancellationRequested)
+      return;
     return result;
   },
   async getColorPresentations(doc, params, cancel) {
     let result;
-    try {
-      for (const pending of plugins.map(
-        (plugin) => {
-          var _a;
-          return (_a = plugin.getColorPresentations) == null ? void 0 : _a.call(plugin, doc, params, cancel);
-        }
-      )) {
-        const cur = await pending;
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
+        var _a;
+        const cur = await ((_a = plugin.getColorPresentations) == null ? void 0 : _a.call(plugin, doc, params, cancel));
         if (cancel.isCancellationRequested)
           return;
         if (cur)
-          result = result ? result.concat(cur) : cur;
-      }
-    } catch (err) {
-      displayError(err);
-    }
+          result = (result || []).concat(cur);
+      })
+    );
+    if (cancel.isCancellationRequested)
+      return;
     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));
+    let result;
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
+        var _a;
+        const cur = 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);
-    }
+        if (cur) {
+          if (result) {
+            result.range = maxRange(result.range, cur.range);
+            result.contents = mergeHoverContents(result.contents, cur.contents);
+          } else {
+            result = cur;
+          }
+        }
+      })
+    );
+    return result;
   },
   async doRename(doc, params, cancel) {
     let changes;
     let changeAnnotations;
     let documentChanges;
-    try {
-      for (const pending of plugins.map(
-        (plugin) => {
-          var _a;
-          return (_a = plugin.doRename) == null ? void 0 : _a.call(plugin, doc, params, cancel);
-        }
-      )) {
-        const cur = await pending;
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
+        var _a;
+        const cur = await ((_a = plugin.doRename) == null ? void 0 : _a.call(plugin, doc, params, cancel));
         if (cancel.isCancellationRequested)
           return;
         if (cur) {
@@ -2385,10 +2779,10 @@ var service = {
             documentChanges = documentChanges ? documentChanges.concat(cur.documentChanges) : cur.documentChanges;
           }
         }
-      }
-    } catch (err) {
-      displayError(err);
-    }
+      })
+    );
+    if (cancel.isCancellationRequested)
+      return;
     if (changes || changeAnnotations || documentChanges) {
       return {
         changes,
@@ -2399,62 +2793,112 @@ var service = {
   },
   async doCodeActions(doc, params, cancel) {
     let result;
-    try {
-      for (const pending of plugins.map(
-        (plugin) => {
-          var _a;
-          return (_a = plugin.doCodeActions) == null ? void 0 : _a.call(plugin, doc, params, cancel);
-        }
-      )) {
-        const cur = await pending;
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
+        var _a;
+        const cur = await ((_a = plugin.doCodeActions) == null ? void 0 : _a.call(plugin, doc, params, cancel));
         if (cancel.isCancellationRequested)
           return;
         if (cur)
-          result = result ? result.concat(cur) : cur;
-      }
-    } catch (err) {
-      displayError(err);
-    }
+          result = (result || []).concat(cur);
+      })
+    );
+    if (cancel.isCancellationRequested)
+      return;
     return result;
   },
   async doValidate(doc) {
     let result;
-    try {
-      for (const pending of plugins.map((plugin) => {
+    await Promise.allSettled(
+      plugins.map(async (plugin) => {
         var _a;
-        return (_a = plugin.doValidate) == null ? void 0 : _a.call(plugin, doc);
-      })) {
-        const cur = await pending;
+        const cur = await ((_a = plugin.doValidate) == null ? void 0 : _a.call(plugin, doc));
         if (cur)
-          result = result ? result.concat(cur) : cur;
-      }
-    } catch (err) {
-      displayError(err);
-    }
+          result = (result || []).concat(cur);
+      })
+    );
     return result;
   },
   format: marko_default.format
 };
+function maxRange(a, b) {
+  if (!a)
+    return b;
+  if (!b)
+    return a;
+  return {
+    start: {
+      line: Math.min(a.start.line, b.start.line),
+      character: Math.min(a.start.character, b.start.character)
+    },
+    end: {
+      line: Math.max(a.end.line, b.end.line),
+      character: Math.max(a.end.character, b.end.character)
+    }
+  };
+}
+function mergeHoverContents(a, b) {
+  if (!a)
+    return b;
+  if (!b)
+    return a;
+  if (!import_vscode_languageserver12.MarkupContent.is(a)) {
+    a = markedStringToMarkupContent(a);
+  }
+  if (!import_vscode_languageserver12.MarkupContent.is(b)) {
+    b = markedStringToMarkupContent(b);
+  }
+  if (a.kind === b.kind) {
+    return {
+      kind: a.kind,
+      value: `${a.value}
+${b.value}`
+    };
+  }
+  return {
+    kind: import_vscode_languageserver12.MarkupKind.Markdown,
+    value: `${markupContentToMarkdown(a)}
+${markupContentToMarkdown(b)}`
+  };
+}
+function markedStringToMarkupContent(markedString) {
+  return {
+    kind: import_vscode_languageserver12.MarkupKind.Markdown,
+    value: Array.isArray(markedString) ? markedString.map((it) => markedStringToString(it)).join("\n") : markedStringToString(markedString)
+  };
+}
+function markedStringToString(markedString) {
+  if (typeof markedString === "string") {
+    return markedString;
+  }
+  return `\`\`\`${markedString.language}
+${markedString.value}
+\`\`\``;
+}
+function markupContentToMarkdown(content) {
+  return content.kind === import_vscode_languageserver12.MarkupKind.Markdown ? content.value : escapeMarkdown(content.value);
+}
+function escapeMarkdown(str) {
+  return str.replace(REG_MARKDOWN_CHARS, "$1");
+}
 
 // src/index.ts
 if (typeof require !== "undefined" && require.extensions && !(".ts" in require.extensions)) {
   require.extensions[".ts"] = void 0;
 }
-var documents = new import_node.TextDocuments(import_vscode_languageserver_textdocument3.TextDocument);
-var connection2 = (0, import_node.createConnection)(import_node.ProposedFeatures.all);
+var connection3 = (0, import_node.createConnection)(import_node.ProposedFeatures.all);
 var prevDiags = /* @__PURE__ */ new WeakMap();
-var pendingDiags = /* @__PURE__ */ new WeakSet();
 var diagnosticTimeout;
 console.log = (...args) => {
-  connection2.console.log(args.map((v) => (0, import_util2.inspect)(v)).join(" "));
+  connection3.console.log(args.map((v) => (0, import_util2.inspect)(v)).join(" "));
 };
 console.error = (...args) => {
-  connection2.console.error(args.map((v) => (0, import_util2.inspect)(v)).join(" "));
+  connection3.console.error(args.map((v) => (0, import_util2.inspect)(v)).join(" "));
 };
 process.on("uncaughtException", console.error);
 process.on("unhandledRejection", console.error);
-connection2.onInitialize(async (params) => {
-  setup(connection2);
+connection3.onInitialize(async (params) => {
+  setup3(connection3);
   await service.initialize(params);
   return {
     capabilities: {
@@ -2470,6 +2914,7 @@ connection2.onInitialize(async (params) => {
       documentHighlightProvider: true,
       documentSymbolProvider: true,
       completionProvider: {
+        resolveProvider: true,
         triggerCharacters: [
           ".",
           ":",
@@ -2495,111 +2940,123 @@ connection2.onInitialize(async (params) => {
     }
   };
 });
-connection2.onDidChangeConfiguration(validateDocs);
-connection2.onDidChangeWatchedFiles(validateDocs);
-documents.onDidChangeContent(({ document }) => {
-  queueDiagnostic();
-  pendingDiags.add(document);
-  clearCompilerCache(document);
+setup2(connection3);
+onConfigChange(validateDocs);
+setup(connection3);
+onFileChange((changeDoc) => {
+  if (changeDoc) {
+    queueDiagnostic();
+    getMarkoProject(getFSDir(changeDoc)).cache.delete(changeDoc);
+  } else {
+    validateDocs();
+  }
 });
-connection2.onCompletion(async (params, cancel) => {
+connection3.onCompletion(async (params, cancel) => {
   return await service.doComplete(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
-connection2.onDefinition(async (params, cancel) => {
+connection3.onCompletionResolve(async (item, cancel) => {
+  return await service.doCompletionResolve(item, cancel) || item;
+});
+connection3.onDefinition(async (params, cancel) => {
   return await service.findDefinition(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
-connection2.onReferences(async (params, cancel) => {
+connection3.onReferences(async (params, cancel) => {
   return await service.findReferences(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
-connection2.onDocumentLinks(async (params, cancel) => {
+connection3.onDocumentLinks(async (params, cancel) => {
   return await service.findDocumentLinks(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
-connection2.onDocumentSymbol(async (params, cancel) => {
+connection3.onDocumentSymbol(async (params, cancel) => {
   return await service.findDocumentSymbols(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
-connection2.onDocumentHighlight(async (params, cancel) => {
+connection3.onDocumentHighlight(async (params, cancel) => {
   return await service.findDocumentHighlights(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
-connection2.onDocumentColor(async (params, cancel) => {
+connection3.onDocumentColor(async (params, cancel) => {
   return await service.findDocumentColors(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
-connection2.onColorPresentation(async (params, cancel) => {
+connection3.onColorPresentation(async (params, cancel) => {
   return await service.getColorPresentations(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
-connection2.onHover(async (params, cancel) => {
+connection3.onHover(async (params, cancel) => {
   return await service.doHover(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
-connection2.onRenameRequest(async (params, cancel) => {
+connection3.onRenameRequest(async (params, cancel) => {
   return await service.doRename(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
-connection2.onCodeAction(async (params, cancel) => {
+connection3.onCodeAction(async (params, cancel) => {
   return await service.doCodeActions(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
-connection2.onDocumentFormatting(async (params, cancel) => {
+connection3.onDocumentFormatting(async (params, cancel) => {
   return await service.format(
-    documents.get(params.textDocument.uri),
+    get(params.textDocument.uri),
     params,
     cancel
   ) || null;
 });
+for (const command in service.commands) {
+  connection3.onRequest(command, service.commands[command]);
+}
 function validateDocs() {
   queueDiagnostic();
-  clearCompilerCache();
-  for (const doc of documents.all()) {
-    pendingDiags.add(doc);
+  for (const project of getMarkoProjects()) {
+    project.cache.clear();
+    project.compiler.taglib.clearCaches();
   }
 }
 function queueDiagnostic() {
   clearTimeout(diagnosticTimeout);
   const id = diagnosticTimeout = setTimeout(async () => {
     const results = await Promise.all(
-      documents.all().map(async (doc) => {
-        if (!pendingDiags.delete(doc))
+      Array.from(getAllOpen()).map(async (doc) => {
+        if (!isOpen(doc)) {
+          prevDiags.delete(doc);
           return;
+        }
         const prevDiag = prevDiags.get(doc) || [];
         const nextDiag = await service.doValidate(doc) || [];
         if ((0, import_util2.isDeepStrictEqual)(prevDiag, nextDiag))
@@ -2612,7 +3069,7 @@ function queueDiagnostic() {
         if (result) {
           const [doc, diag] = result;
           prevDiags.set(doc, diag);
-          connection2.sendDiagnostics({
+          connection3.sendDiagnostics({
             uri: doc.uri,
             diagnostics: diag
           });
@@ -2621,6 +3078,5 @@ function queueDiagnostic() {
     }
   }, 400);
 }
-documents.listen(connection2);
-connection2.listen();
+connection3.listen();
 //# sourceMappingURL=index.js.map