@fluixi/ts-plugin 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/index.js

@@ -1,36 +1,36 @@
 "use strict";
 
 // ../template-parser/dist/index.mjs
-function N(t) {
-  let e = (i, r) => {
-    i.parent = r;
-    let n = C(i);
-    for (let s of n) e(s, i);
+function x(e) {
+  let t = (i2, n) => {
+    i2.parent = n;
+    let r = R(i2);
+    for (let s2 of r) t(s2, i2);
   };
-  return e(t, null), t;
+  return t(e, null), e;
 }
-function C(t) {
-  switch (t.kind) {
+function R(e) {
+  switch (e.kind) {
     case "Root":
     case "Element":
     case "Component":
     case "Fragment":
-      return t.children;
+      return e.children;
     default:
       return [];
   }
 }
-var u = class {
-  constructor(e) {
-    this.pieces = e;
+var m = class {
+  constructor(t) {
+    this.pieces = t;
     this.pi = 0;
     this.oi = 0;
     this.normalize();
   }
   normalize() {
     for (; this.pi < this.pieces.length; ) {
-      let e = this.pieces[this.pi];
-      if (e.kind === "static" && this.oi >= e.text.length) {
+      let t = this.pieces[this.pi];
+      if (t.kind === "static" && this.oi >= t.text.length) {
         this.pi++, this.oi = 0;
         continue;
       }
@@ -42,132 +42,172 @@ var u = class {
   }
   pos() {
     if (this.eof()) {
-      let i = this.pieces[this.pieces.length - 1];
-      return i ? i.kind === "static" ? i.start + i.text.length : i.end : 0;
+      let i2 = this.pieces[this.pieces.length - 1];
+      return i2 ? i2.kind === "static" ? i2.start + i2.text.length : i2.end : 0;
     }
-    let e = this.pieces[this.pi];
-    return e.kind === "static" ? e.start + this.oi : e.start;
+    let t = this.pieces[this.pi];
+    return t.kind === "static" ? t.start + this.oi : t.start;
   }
   atHole() {
     return !this.eof() && this.pieces[this.pi].kind === "hole";
   }
   holeFollows() {
     if (this.eof()) return false;
-    let e = this.pieces[this.pi];
-    if (e.kind !== "static" || this.oi + 1 < e.text.length) return false;
-    let i = this.pieces[this.pi + 1];
-    return i !== void 0 && i.kind === "hole";
+    let t = this.pieces[this.pi];
+    if (t.kind !== "static" || this.oi + 1 < t.text.length) return false;
+    let i2 = this.pieces[this.pi + 1];
+    return i2 !== void 0 && i2.kind === "hole";
   }
   takeHole() {
-    let e = this.pieces[this.pi];
-    if (e.kind !== "hole") throw new Error("takeHole called off a hole");
-    return this.pi++, this.oi = 0, this.normalize(), { index: e.index, loc: { start: e.start, end: e.end } };
+    let t = this.pieces[this.pi];
+    if (t.kind !== "hole") throw new Error("takeHole called off a hole");
+    return this.pi++, this.oi = 0, this.normalize(), { index: t.index, loc: { start: t.start, end: t.end } };
   }
-  peek(e = 0) {
+  peek(t = 0) {
     if (this.eof()) return "";
-    let i = this.pieces[this.pi];
-    return i.kind !== "static" ? "" : i.text[this.oi + e] ?? "";
+    let i2 = this.pieces[this.pi];
+    return i2.kind !== "static" ? "" : i2.text[this.oi + t] ?? "";
   }
-  startsWith(e) {
+  startsWith(t) {
     if (this.eof()) return false;
-    let i = this.pieces[this.pi];
-    return i.kind !== "static" ? false : i.text.startsWith(e, this.oi);
+    let i2 = this.pieces[this.pi];
+    return i2.kind !== "static" ? false : i2.text.startsWith(t, this.oi);
   }
   advance() {
     if (this.eof()) return "";
-    let e = this.pieces[this.pi];
-    if (e.kind !== "static") return "";
-    let i = e.text[this.oi++] ?? "";
-    return this.normalize(), i;
+    let t = this.pieces[this.pi];
+    if (t.kind !== "static") return "";
+    let i2 = t.text[this.oi++] ?? "";
+    return this.normalize(), i2;
   }
-  readWhile(e) {
-    let i = "";
+  readWhile(t) {
+    let i2 = "";
     for (; !this.eof() && !this.atHole(); ) {
-      let r = this.peek();
-      if (r === "" || !e(r)) break;
-      i += r, this.oi++;
+      let n = this.peek();
+      if (n === "" || !t(n)) break;
+      i2 += n, this.oi++;
     }
-    return this.normalize(), i;
+    return this.normalize(), i2;
   }
   skipWhitespace() {
-    this.readWhile((e) => /\s/.test(e));
+    this.readWhile((t) => /\s/.test(t));
   }
-  span(e) {
-    return { start: e, end: this.pos() };
+  span(t) {
+    return { start: t, end: this.pos() };
   }
 };
-var x = /* @__PURE__ */ new Set(["capture", "once", "passive", "prevent", "stop", "self"]);
-function p(t, e) {
-  return t.value && t.value.kind === "hole" ? t.value.hole : (t.report("invalid-binding", `${e} requires an expression value: ${t.name}=\${\u2026}`), -1);
-}
-var b = (t, e) => ({ kind: "Attribute", name: e ? t.name.slice(1) : t.name, value: t.value, boolean: e, loc: t.loc });
-var m = [{ id: "event", match: (t) => t[0] === "@" || t.startsWith("on:") || /^on[A-Z]/.test(t), build: (t) => {
-  let e, i;
-  t.name[0] === "@" ? (e = "at", i = t.name.slice(1)) : t.name.startsWith("on:") ? (e = "colon", i = t.name.slice(3)) : (e = "on", i = t.name.slice(2));
-  let [r, ...n] = i.split(".");
-  for (let s of n) x.has(s) || t.report("invalid-directive", `Unknown event modifier ".${s}" \u2014 expected one of ${[...x].join(", ")}`);
-  return { kind: "EventBinding", name: r, syntax: e, modifiers: n, hole: p(t, "event binding"), loc: t.loc };
-} }, { id: "bind", elementOnly: true, match: (t) => t.startsWith("bind:"), build: (t) => ({ kind: "BindDirective", name: t.name.slice(5), hole: p(t, "two-way binding"), loc: t.loc }) }, { id: "class-directive", elementOnly: true, match: (t) => t.startsWith("class:"), build: (t) => ({ kind: "ClassDirective", name: t.name.slice(6), hole: p(t, "class directive"), loc: t.loc }) }, { id: "style-directive", elementOnly: true, match: (t) => t.startsWith("style:"), build: (t) => ({ kind: "StyleDirective", name: t.name.slice(6), hole: p(t, "style directive"), loc: t.loc }) }, { id: "use", match: (t) => t === "use" || t.startsWith("use:"), build: (t) => ({ kind: "UseDirective", name: t.name.startsWith("use:") ? t.name.slice(4) : null, hole: t.value && t.value.kind === "hole" ? t.value.hole : null, loc: t.loc }) }, { id: "if", elementOnly: true, match: (t) => t === "if", build: (t) => ({ kind: "IfDirective", hole: p(t, "if directive"), loc: t.loc }) }, { id: "each", elementOnly: true, match: (t) => t === "each", build: (t) => ({ kind: "EachDirective", hole: p(t, "each directive"), key: null, loc: t.loc }) }, { id: "else", elementOnly: true, match: (t) => t === "else", build: (t) => (t.value !== null && t.report("invalid-directive", "`else` takes no value"), { kind: "ElseDirective", loc: t.loc }) }, { id: "ref", match: (t) => t === "ref", build: (t) => ({ kind: "RefBinding", hole: p(t, "ref binding"), loc: t.loc }) }, { id: "property", match: (t) => t[0] === ".", build: (t) => ({ kind: "PropertyBinding", name: t.name.slice(1), hole: p(t, "property binding"), loc: t.loc }) }, { id: "boolean", match: (t) => t[0] === "?", build: (t) => b(t, true) }];
-function v(t, e = m, i = { component: false }) {
-  for (let r of e) if (!(r.elementOnly && i.component) && r.match(t.name)) return r.build(t);
-  return b(t, false);
-}
-var y = /* @__PURE__ */ new Set(["svg", "path", "circle", "rect", "line", "polygon", "polyline", "ellipse", "g", "defs", "clipPath", "text"]);
-var D = /* @__PURE__ */ new Set(["script", "style", "textarea", "title"]);
-var E = /* @__PURE__ */ new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
-function S(t) {
-  return t.length > 0 && (t[0] !== t[0].toLowerCase() || t.includes("."));
-}
-var T = /[A-Za-z0-9\-_:@.?]/;
-var g = class {
-  constructor(e, i) {
+var y = /* @__PURE__ */ new Set(["capture", "once", "passive", "prevent", "stop", "self"]);
+function p(e, t) {
+  return e.value && e.value.kind === "hole" ? e.value.hole : (e.report("invalid-binding", `${t} requires an expression value: ${e.name}=\${\u2026}`), -1);
+}
+var D = (e, t) => ({ kind: "Attribute", name: t ? e.name.slice(1) : e.name, value: e.value, boolean: t, loc: e.loc });
+var f = [{ id: "event", match: (e) => e[0] === "@" || e.startsWith("on:") || /^on[A-Z]/.test(e), build: (e) => {
+  let t, i2;
+  e.name[0] === "@" ? (t = "at", i2 = e.name.slice(1)) : e.name.startsWith("on:") ? (t = "colon", i2 = e.name.slice(3)) : (t = "on", i2 = e.name.slice(2));
+  let [n, ...r] = i2.split("."), s2 = n.toLowerCase();
+  for (let o of r) y.has(o) || e.report("invalid-directive", `Unknown event modifier ".${o}" \u2014 expected one of ${[...y].join(", ")}`);
+  return { kind: "EventBinding", name: s2, syntax: t, modifiers: r, hole: p(e, "event binding"), loc: e.loc };
+} }, { id: "bind", elementOnly: true, match: (e) => e.startsWith("bind:"), build: (e) => ({ kind: "BindDirective", name: e.name.slice(5), hole: p(e, "two-way binding"), loc: e.loc }) }, { id: "class-directive", elementOnly: true, match: (e) => e.startsWith("class:"), build: (e) => ({ kind: "ClassDirective", name: e.name.slice(6), hole: p(e, "class directive"), loc: e.loc }) }, { id: "style-directive", elementOnly: true, match: (e) => e.startsWith("style:"), build: (e) => ({ kind: "StyleDirective", name: e.name.slice(6), hole: p(e, "style directive"), loc: e.loc }) }, { id: "load", match: (e) => e.startsWith("load:"), build: (e) => ({ kind: "LoadDirective", strategy: e.name.slice(5), modifier: e.value && e.value.kind === "static" ? e.value.value : null, loc: e.loc }) }, { id: "use", match: (e) => e === "use" || e.startsWith("use:"), build: (e) => ({ kind: "UseDirective", name: e.name.startsWith("use:") ? e.name.slice(4) : null, hole: e.value && e.value.kind === "hole" ? e.value.hole : null, loc: e.loc }) }, { id: "if", elementOnly: true, match: (e) => e === "if", build: (e) => ({ kind: "IfDirective", hole: p(e, "if directive"), loc: e.loc }) }, { id: "each", elementOnly: true, match: (e) => e === "each", build: (e) => ({ kind: "EachDirective", hole: p(e, "each directive"), key: null, loc: e.loc }) }, { id: "else", elementOnly: true, match: (e) => e === "else", build: (e) => (e.value !== null && e.report("invalid-directive", "`else` takes no value"), { kind: "ElseDirective", loc: e.loc }) }, { id: "ref", match: (e) => e === "ref", build: (e) => ({ kind: "RefBinding", hole: p(e, "ref binding"), loc: e.loc }) }, { id: "property", match: (e) => e[0] === ".", build: (e) => ({ kind: "PropertyBinding", name: e.name.slice(1), hole: p(e, "property binding"), loc: e.loc }) }, { id: "boolean", match: (e) => e[0] === "?", build: (e) => D(e, true) }];
+function k(e, t = f, i2 = { component: false }) {
+  for (let n of t) if (!(n.elementOnly && i2.component) && n.match(e.name)) return n.build(e);
+  return D(e, false);
+}
+var E = /* @__PURE__ */ new Set(["svg", "path", "circle", "rect", "line", "polygon", "polyline", "ellipse", "g", "defs", "clipPath", "text"]);
+var S = /* @__PURE__ */ new Set(["script", "style", "textarea", "title"]);
+var T = /* @__PURE__ */ new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
+function C(e) {
+  return e.length > 0 && (e[0] !== e[0].toLowerCase() || e.includes("."));
+}
+var P = /* @__PURE__ */ new Set(["a", "button", "input", "select", "textarea", "summary", "details", "option", "label"]);
+var W = /* @__PURE__ */ new Set(["keydown", "keyup", "keypress"]);
+function u(e, t) {
+  return e.attributes.find((i2) => "name" in i2 && i2.name === t);
+}
+function w(e) {
+  return e.attributes.some((t) => t.kind === "Spread");
+}
+function v(e, t) {
+  let i2 = u(e, t);
+  if (!i2 || i2.kind !== "Attribute" || !i2.value) return;
+  let n = i2.value;
+  return n.kind === "static" ? n.value : void 0;
+}
+function H(e) {
+  let t = v(e, "role");
+  return t === "presentation" || t === "none" ? true : v(e, "aria-hidden") === "true";
+}
+function A(e, t) {
+  return e.attributes.some((i2) => i2.kind === "EventBinding" && t(i2.name));
+}
+function B(e) {
+  let t = [], i2 = (r, s2, o) => {
+    t.push({ code: s2, message: o, severity: "warning", loc: r.loc });
+  }, n = (r) => {
+    for (let s2 of r) {
+      s2.kind === "Element" && L(s2, i2);
+      let o = "children" in s2 ? s2.children : void 0;
+      o && n(o);
+    }
+  };
+  return n(e.children), t;
+}
+function L(e, t) {
+  if (w(e)) return;
+  let i2 = e.tag.toLowerCase();
+  i2 === "img" && !u(e, "alt") && !H(e) && t(e, "a11y-img-alt", 'An `img` needs an `alt`. Use `alt=""` when the image is decorative.'), i2 === "a" && !u(e, "href") && !u(e, "role") && t(e, "a11y-anchor-href", "An `a` without `href` is not a link. Use a `button` for an action."), i2 === "iframe" && !u(e, "title") && t(e, "a11y-iframe-title", "An `iframe` needs a `title` describing its content.");
+  let n = v(e, "tabindex") ?? v(e, "tabIndex");
+  n !== void 0 && Number(n) > 0 && t(e, "a11y-positive-tabindex", "A positive `tabindex` reorders tab navigation for the entire page. Use `0`, or restructure the markup."), !P.has(i2) && A(e, (r) => r === "click") && !u(e, "role") && !A(e, (r) => W.has(r)) && t(e, "a11y-click-without-keyboard", `A click handler on \`${i2}\` is unreachable by keyboard. Use a \`button\`, or add a \`role\` and a key handler.`);
+}
+var V = /[A-Za-z0-9\-_:@.?]/;
+var N = class {
+  constructor(t, i2) {
     this.diagnostics = [];
-    this.r = new u(e), this.svg = i.svg ?? false, this.directives = i.directives ?? m;
+    this.r = new m(t), this.svg = i2.svg ?? false, this.directives = i2.directives ?? f, this.accessibility = i2.accessibility ?? true;
   }
   parse() {
-    let e = this.r.pos(), i = [];
-    for (; !this.r.eof() && (i.push(...this.parseChildren()), !this.r.eof()); ) {
-      let n = this.r.pos();
-      this.consumeCloseTag(), this.report("stray-close-tag", "error", "Close tag without a matching open tag", this.r.span(n));
+    let t = this.r.pos(), i2 = [];
+    for (; !this.r.eof() && (i2.push(...this.parseChildren()), !this.r.eof()); ) {
+      let r = this.r.pos();
+      this.consumeCloseTag(), this.report("stray-close-tag", "error", "Close tag without a matching open tag", this.r.span(r));
     }
-    let r = { kind: "Root", children: i, loc: this.r.span(e) };
-    return N(r), this.validateTree(r), { root: r, diagnostics: this.diagnostics };
+    let n = { kind: "Root", children: i2, loc: this.r.span(t) };
+    return x(n), this.validateTree(n), this.accessibility && this.diagnostics.push(...B(n)), { root: n, diagnostics: this.diagnostics };
   }
-  validateTree(e) {
-    let i = (r) => {
-      let n = null;
-      for (let s of r) s.kind === "Text" && /^\s*$/.test(s.value) || (s.kind === "Element" || s.kind === "Component" ? (s.attributes.some((l) => l.kind === "ElseDirective") && (n != null && (n.kind === "Element" || n.kind === "Component") && n.attributes.some((o) => o.kind === "IfDirective") || this.report("else-without-if", "error", "`else` must immediately follow an element with `if`", s.loc)), n = s) : n = null, "children" in s && s.children && i(s.children));
+  validateTree(t) {
+    let i2 = (n) => {
+      let r = null;
+      for (let s2 of n) s2.kind === "Text" && /^\s*$/.test(s2.value) || (s2.kind === "Element" || s2.kind === "Component" ? (s2.attributes.some((l2) => l2.kind === "ElseDirective") && (r != null && (r.kind === "Element" || r.kind === "Component") && r.attributes.some((a2) => a2.kind === "IfDirective") || this.report("else-without-if", "error", "`else` must immediately follow an element with `if`", s2.loc)), r = s2) : r = null, "children" in s2 && s2.children && i2(s2.children));
     };
-    i(e.children);
+    i2(t.children);
   }
   parseChildren() {
-    let e = [];
+    let t = [];
     for (; !this.r.eof() && !this.r.startsWith("</"); ) {
       if (this.r.startsWith("<!--")) {
-        e.push(this.parseComment());
+        t.push(this.parseComment());
         continue;
       }
       if (this.isFragmentStart()) {
-        e.push(this.parseFragment());
+        t.push(this.parseFragment());
         continue;
       }
       if (this.isDynamicTagStart()) {
-        e.push(this.parseDynamicComponent());
+        t.push(this.parseDynamicComponent());
         continue;
       }
       if (this.isTagStart()) {
-        e.push(this.parseElement());
+        t.push(this.parseElement());
         continue;
       }
       if (this.r.atHole()) {
-        let r = this.r.takeHole(), n = { kind: "Expression", hole: r.index, loc: r.loc };
-        e.push(n);
+        let n = this.r.takeHole(), r = { kind: "Expression", hole: n.index, loc: n.loc };
+        t.push(r);
         continue;
       }
-      let i = this.readText();
-      i && e.push(i);
+      let i2 = this.readText();
+      i2 && t.push(i2);
     }
-    return e;
+    return t;
   }
   isTagStart() {
     return this.r.peek() === "<" && /[A-Za-z]/.test(this.r.peek(1));
@@ -179,171 +219,171 @@ var g = class {
     return this.r.peek() === "<" && this.r.holeFollows();
   }
   parseDynamicComponent() {
-    let e = this.r.pos();
+    let t = this.r.pos();
     this.r.advance();
-    let i = this.r.takeHole().index, r = this.parseAttributes(true);
+    let i2 = this.r.takeHole().index, n = this.parseAttributes(true);
     this.r.skipWhitespace();
-    let n = false, s = [];
-    return this.r.startsWith("/>") ? (this.r.advance(), this.r.advance(), n = true) : (this.r.peek() === ">" && this.r.advance(), s = this.parseChildren(), this.r.startsWith("</") ? (this.r.advance(), this.r.advance(), this.r.atHole() ? this.r.takeHole() : this.readName(), this.r.skipWhitespace(), this.r.peek() === ">" && this.r.advance()) : this.report("unclosed-tag", "error", "Unclosed dynamic component", this.r.span(e))), { kind: "Component", tag: "", tagHole: i, attributes: r, children: s, selfClosing: n, loc: this.r.span(e) };
+    let r = false, s2 = [];
+    return this.r.startsWith("/>") ? (this.r.advance(), this.r.advance(), r = true) : (this.r.peek() === ">" && this.r.advance(), s2 = this.parseChildren(), this.r.startsWith("</") ? (this.r.advance(), this.r.advance(), this.r.atHole() ? this.r.takeHole() : this.readName(), this.r.skipWhitespace(), this.r.peek() === ">" && this.r.advance()) : this.report("unclosed-tag", "error", "Unclosed dynamic component", this.r.span(t))), { kind: "Component", tag: "", tagHole: i2, attributes: n, children: s2, selfClosing: r, loc: this.r.span(t) };
   }
   readText() {
-    let e = this.r.pos(), i = "";
-    for (; !this.r.eof() && !this.r.atHole() && !(this.r.startsWith("</") || this.r.startsWith("<!--") || this.isTagStart() || this.isFragmentStart() || this.isDynamicTagStart()); ) i += this.r.advance();
-    return i ? { kind: "Text", value: i, raw: false, loc: this.r.span(e) } : null;
+    let t = this.r.pos(), i2 = "";
+    for (; !this.r.eof() && !this.r.atHole() && !(this.r.startsWith("</") || this.r.startsWith("<!--") || this.isTagStart() || this.isFragmentStart() || this.isDynamicTagStart()); ) i2 += this.r.advance();
+    return i2 ? { kind: "Text", value: i2, raw: false, loc: this.r.span(t) } : null;
   }
   parseComment() {
-    let e = this.r.pos();
+    let t = this.r.pos();
     this.r.advance(), this.r.advance(), this.r.advance(), this.r.advance();
-    let i = "";
+    let i2 = "";
     for (; !this.r.eof() && !this.r.startsWith("-->"); ) {
       if (this.r.atHole()) {
-        this.r.takeHole(), i += "\0";
+        this.r.takeHole(), i2 += "\0";
         continue;
       }
-      i += this.r.advance();
+      i2 += this.r.advance();
     }
-    return this.r.startsWith("-->") ? (this.r.advance(), this.r.advance(), this.r.advance()) : this.report("unclosed-comment", "warning", "Unterminated comment", this.r.span(e)), { kind: "Comment", value: i, loc: this.r.span(e) };
+    return this.r.startsWith("-->") ? (this.r.advance(), this.r.advance(), this.r.advance()) : this.report("unclosed-comment", "warning", "Unterminated comment", this.r.span(t)), { kind: "Comment", value: i2, loc: this.r.span(t) };
   }
   parseFragment() {
-    let e = this.r.pos();
+    let t = this.r.pos();
     this.r.advance(), this.r.advance();
-    let i = this.parseChildren();
+    let i2 = this.parseChildren();
     if (this.r.startsWith("</")) {
-      let r = this.consumeCloseTag();
-      r && this.report("mismatched-close-tag", "error", `Expected </> to close fragment, got </${r}>`, this.r.span(e));
-    } else this.report("unclosed-tag", "error", "Unterminated fragment", this.r.span(e));
-    return { kind: "Fragment", children: i, loc: this.r.span(e) };
+      let n = this.consumeCloseTag();
+      n && this.report("mismatched-close-tag", "error", `Expected </> to close fragment, got </${n}>`, this.r.span(t));
+    } else this.report("unclosed-tag", "error", "Unterminated fragment", this.r.span(t));
+    return { kind: "Fragment", children: i2, loc: this.r.span(t) };
   }
   parseElement() {
-    let e = this.r.pos();
+    let t = this.r.pos();
     this.r.advance();
-    let i = this.readName(), r = S(i), n = this.parseAttributes(r);
-    this.foldEachKey(n, e), this.r.skipWhitespace();
-    let s = i.toLowerCase(), a = !r && D.has(s), l = !r && E.has(s), o = false, c = [];
-    if (this.r.startsWith("/>")) this.r.advance(), this.r.advance(), o = true;
-    else if (this.r.peek() === ">" && this.r.advance(), !l) if (c = a ? this.parseRawText(i) : this.parseChildren(), this.r.startsWith("</")) {
-      let f = this.consumeCloseTag();
-      f && f !== i && this.report("mismatched-close-tag", "error", `Expected </${i}>, got </${f}>`, this.r.span(e));
-    } else this.report("unclosed-tag", "error", `Unclosed <${i}>`, this.r.span(e));
-    let h = this.r.span(e);
-    if (r) return { kind: "Component", tag: i, tagHole: null, attributes: n, children: c, selfClosing: o, loc: h };
-    let d = this.svg || y.has(i) ? "svg" : "html";
-    return { kind: "Element", tag: i, namespace: d, attributes: n, children: c, selfClosing: o, rawText: a, loc: h };
-  }
-  parseRawText(e) {
-    let i = [], r = "</" + e.toLowerCase(), n = "", s = this.r.pos(), a = () => {
-      n && i.push({ kind: "Text", value: n, raw: true, loc: this.r.span(s) }), n = "";
+    let i2 = this.readName(), n = C(i2), r = this.parseAttributes(n);
+    this.foldEachKey(r, t), this.r.skipWhitespace();
+    let s2 = i2.toLowerCase(), o = !n && S.has(s2), l2 = !n && T.has(s2), a2 = false, c = [];
+    if (this.r.startsWith("/>")) this.r.advance(), this.r.advance(), a2 = true;
+    else if (this.r.peek() === ">" && this.r.advance(), !l2) if (c = o ? this.parseRawText(i2) : this.parseChildren(), this.r.startsWith("</")) {
+      let g = this.consumeCloseTag();
+      g && g !== i2 && this.report("mismatched-close-tag", "error", `Expected </${i2}>, got </${g}>`, this.r.span(t));
+    } else this.report("unclosed-tag", "error", `Unclosed <${i2}>`, this.r.span(t));
+    let h = this.r.span(t);
+    if (n) return { kind: "Component", tag: i2, tagHole: null, attributes: r, children: c, selfClosing: a2, loc: h };
+    let d = this.svg || E.has(i2) ? "svg" : "html";
+    return { kind: "Element", tag: i2, namespace: d, attributes: r, children: c, selfClosing: a2, rawText: o, loc: h };
+  }
+  parseRawText(t) {
+    let i2 = [], n = "</" + t.toLowerCase(), r = "", s2 = this.r.pos(), o = () => {
+      r && i2.push({ kind: "Text", value: r, raw: true, loc: this.r.span(s2) }), r = "";
     };
-    for (; !this.r.eof() && !this.startsWithCloseFor(r); ) {
+    for (; !this.r.eof() && !this.startsWithCloseFor(n); ) {
       if (this.r.atHole()) {
-        a();
-        let l = this.r.takeHole();
-        i.push({ kind: "Expression", hole: l.index, loc: l.loc }), s = this.r.pos();
+        o();
+        let l2 = this.r.takeHole();
+        i2.push({ kind: "Expression", hole: l2.index, loc: l2.loc }), s2 = this.r.pos();
         continue;
       }
-      n || (s = this.r.pos()), n += this.r.advance();
+      r || (s2 = this.r.pos()), r += this.r.advance();
     }
-    return a(), i;
-  }
-  startsWithCloseFor(e) {
-    let i = 0;
-    for (; i < e.length; ) {
-      let r = this.r.peek(i);
-      if (r === "" || r.toLowerCase() !== e[i]) return false;
-      i++;
+    return o(), i2;
+  }
+  startsWithCloseFor(t) {
+    let i2 = 0;
+    for (; i2 < t.length; ) {
+      let n = this.r.peek(i2);
+      if (n === "" || n.toLowerCase() !== t[i2]) return false;
+      i2++;
     }
     return true;
   }
-  parseAttributes(e) {
-    let i = [];
+  parseAttributes(t) {
+    let i2 = [];
     for (; !this.r.eof() && (this.r.skipWhitespace(), !(this.r.peek() === ">" || this.r.startsWith("/>"))); ) {
       if (this.r.atHole()) {
-        let o = this.r.takeHole();
-        i.push({ kind: "Spread", hole: o.index, loc: o.loc });
+        let a2 = this.r.takeHole();
+        i2.push({ kind: "Spread", hole: a2.index, loc: a2.loc });
         continue;
       }
       if (this.r.startsWith("...")) {
-        let o = this.r.pos();
+        let a2 = this.r.pos();
         if (this.r.advance(), this.r.advance(), this.r.advance(), this.r.atHole()) {
           let c = this.r.takeHole();
-          i.push({ kind: "Spread", hole: c.index, loc: this.r.span(o) });
-        } else this.report("invalid-binding", "error", "Spread `...` must be followed by ${\u2026}", this.r.span(o));
+          i2.push({ kind: "Spread", hole: c.index, loc: this.r.span(a2) });
+        } else this.report("invalid-binding", "error", "Spread `...` must be followed by ${\u2026}", this.r.span(a2));
         continue;
       }
-      let r = this.r.pos(), n = this.readName();
-      if (!n) {
+      let n = this.r.pos(), r = this.readName();
+      if (!r) {
         this.r.advance();
         continue;
       }
-      let s = this.r.span(r);
+      let s2 = this.r.span(n);
       this.r.skipWhitespace();
-      let a = null;
-      this.r.peek() === "=" && (this.r.advance(), this.r.skipWhitespace(), a = this.parseAttrValue());
-      let l = { name: n, nameLoc: s, value: a, loc: this.r.span(r), report: (o, c) => this.report(o, "error", c, this.r.span(r)) };
-      i.push(v(l, this.directives, { component: e }));
+      let o = null;
+      this.r.peek() === "=" && (this.r.advance(), this.r.skipWhitespace(), o = this.parseAttrValue());
+      let l2 = { name: r, nameLoc: s2, value: o, loc: this.r.span(n), report: (a2, c) => this.report(a2, "error", c, this.r.span(n)) };
+      i2.push(k(l2, this.directives, { component: t }));
     }
-    return i;
+    return i2;
   }
   parseAttrValue() {
     if (this.r.atHole()) return { kind: "hole", hole: this.r.takeHole().index };
-    let e = this.r.peek();
-    return e === '"' || e === "'" ? this.classifyParts(this.readQuotedParts(e)) : { kind: "static", value: this.r.readWhile((r) => !/[\s>]/.test(r)) };
+    let t = this.r.peek();
+    return t === '"' || t === "'" ? this.classifyParts(this.readQuotedParts(t)) : { kind: "static", value: this.r.readWhile((n) => !/[\s>]/.test(n)) };
   }
-  readQuotedParts(e) {
+  readQuotedParts(t) {
     this.r.advance();
-    let i = [], r = "";
-    for (; !this.r.eof() && this.r.peek() !== e; ) {
+    let i2 = [], n = "";
+    for (; !this.r.eof() && this.r.peek() !== t; ) {
       if (this.r.atHole()) {
-        r && (i.push({ text: r }), r = ""), i.push({ hole: this.r.takeHole().index });
+        n && (i2.push({ text: n }), n = ""), i2.push({ hole: this.r.takeHole().index });
         continue;
       }
-      let n = this.r.advance();
-      if (n === "") break;
-      r += n;
+      let r = this.r.advance();
+      if (r === "") break;
+      n += r;
     }
-    return r && i.push({ text: r }), this.r.peek() === e && this.r.advance(), i;
-  }
-  classifyParts(e) {
-    let i = e.filter((r) => "hole" in r);
-    return i.length === 0 ? { kind: "static", value: e.map((r) => "text" in r ? r.text : "").join("") } : e.length === 1 ? { kind: "hole", hole: i[0].hole } : { kind: "mixed", parts: e };
-  }
-  foldEachKey(e, i) {
-    let r = null, n = 0, s = 0, a = 0, l = 0;
-    for (let d of e) d.kind === "EachDirective" ? (r = d, s++) : d.kind === "IfDirective" ? n++ : d.kind === "ElseDirective" ? a++ : d.kind === "RefBinding" && l++;
-    let o = this.r.span(i);
-    s > 1 && this.report("duplicate-directive", "error", "Multiple `each` directives on one element", o), n > 1 && this.report("duplicate-directive", "error", "Multiple `if` directives on one element", o), l > 1 && this.report("duplicate-directive", "error", "Multiple `ref` bindings on one element", o), n > 0 && s > 0 && this.report("unsupported-combination", "error", "`if` and `each` cannot both apply to one element \u2014 wrap one in another element", o), n > 0 && a > 0 && this.report("invalid-directive", "error", "`if` and `else` cannot be on the same element", o);
-    let c = e.findIndex((d) => d.kind === "Attribute" && d.name === "key");
-    if (!r) {
-      c !== -1 && this.report("invalid-directive", "error", "`key` requires an `each` directive on the same element", o);
+    return n && i2.push({ text: n }), this.r.peek() === t && this.r.advance(), i2;
+  }
+  classifyParts(t) {
+    let i2 = t.filter((n) => "hole" in n);
+    return i2.length === 0 ? { kind: "static", value: t.map((n) => "text" in n ? n.text : "").join("") } : t.length === 1 ? { kind: "hole", hole: i2[0].hole } : { kind: "mixed", parts: t };
+  }
+  foldEachKey(t, i2) {
+    let n = null, r = 0, s2 = 0, o = 0, l2 = 0;
+    for (let d of t) d.kind === "EachDirective" ? (n = d, s2++) : d.kind === "IfDirective" ? r++ : d.kind === "ElseDirective" ? o++ : d.kind === "RefBinding" && l2++;
+    let a2 = this.r.span(i2);
+    s2 > 1 && this.report("duplicate-directive", "error", "Multiple `each` directives on one element", a2), r > 1 && this.report("duplicate-directive", "error", "Multiple `if` directives on one element", a2), l2 > 1 && this.report("duplicate-directive", "error", "Multiple `ref` bindings on one element", a2), r > 0 && s2 > 0 && this.report("unsupported-combination", "error", "`if` and `each` cannot both apply to one element \u2014 wrap one in another element", a2), r > 0 && o > 0 && this.report("invalid-directive", "error", "`if` and `else` cannot be on the same element", a2);
+    let c = t.findIndex((d) => d.kind === "Attribute" && d.name === "key");
+    if (!n) {
+      c !== -1 && this.report("invalid-directive", "error", "`key` requires an `each` directive on the same element", a2);
       return;
     }
     if (c === -1) return;
-    let h = e[c];
-    h.kind === "Attribute" && h.value && (h.value.kind === "static" ? r.key = { static: h.value.value } : h.value.kind === "hole" && (r.key = { hole: h.value.hole })), e.splice(c, 1);
+    let h = t[c];
+    h.kind === "Attribute" && h.value && (h.value.kind === "static" ? n.key = { static: h.value.value } : h.value.kind === "hole" && (n.key = { hole: h.value.hole })), t.splice(c, 1);
   }
   readName() {
-    return this.r.readWhile((e) => T.test(e));
+    return this.r.readWhile((t) => V.test(t));
   }
   consumeCloseTag() {
     this.r.advance(), this.r.advance();
-    let e = this.readName();
-    return this.r.skipWhitespace(), this.r.peek() === ">" && this.r.advance(), e;
+    let t = this.readName();
+    return this.r.skipWhitespace(), this.r.peek() === ">" && this.r.advance(), t;
   }
-  report(e, i, r, n) {
-    this.diagnostics.push({ code: e, severity: i, message: r, loc: n });
+  report(t, i2, n, r) {
+    this.diagnostics.push({ code: t, severity: i2, message: n, loc: r });
   }
 };
-function k(t, e = {}) {
-  return new g(t, e).parse();
+function b(e, t = {}) {
+  return new N(e, t).parse();
 }
-function A(t) {
-  let e = [], i = 0;
-  return t.forEach((r, n) => {
-    e.push({ kind: "static", text: r, start: i }), i += r.length, n < t.length - 1 && e.push({ kind: "hole", index: n, start: i, end: i });
-  }), e;
+function I(e) {
+  let t = [], i2 = 0;
+  return e.forEach((n, r) => {
+    t.push({ kind: "static", text: n, start: i2 }), i2 += n.length, r < e.length - 1 && t.push({ kind: "hole", index: r, start: i2, end: i2 });
+  }), t;
 }
-function F(t, e = {}) {
-  return k(A(t), e);
+function Q(e, t = {}) {
+  return b(I(e), t);
 }
 
 // src/collect.ts
@@ -355,7 +395,7 @@ function usedComponentTags(ts, sourceFile) {
   const tags = /* @__PURE__ */ new Set();
   const visit = (node) => {
     if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && (node.tag.text === "html" || node.tag.text === "svg")) {
-      collectTags(F(templateStatics(ts, node.template)).root.children, tags);
+      collectTags(Q(templateStatics(ts, node.template)).root.children, tags);
     }
     ts.forEachChild(node, visit);
   };
@@ -411,53 +451,214 @@ function importedNames(ts, decl) {
 }
 
 // src/pieces.ts
+function rawContent(ts, node, sf) {
+  const text = node.getText(sf);
+  const closesWithSubstitution = ts.isTemplateHead(node) || ts.isTemplateMiddle(node);
+  return text.slice(1, closesWithSubstitution ? -2 : -1);
+}
 function templatePieces(ts, tpl, sf) {
   if (ts.isNoSubstitutionTemplateLiteral(tpl)) {
-    return [{ kind: "static", text: tpl.text, start: tpl.getStart(sf) + 1 }];
+    return [{ kind: "static", text: rawContent(ts, tpl, sf), start: tpl.getStart(sf) + 1 }];
   }
-  const pieces = [{ kind: "static", text: tpl.head.text, start: tpl.head.getStart(sf) + 1 }];
-  tpl.templateSpans.forEach((span, i) => {
+  const pieces = [
+    { kind: "static", text: rawContent(ts, tpl.head, sf), start: tpl.head.getStart(sf) + 1 }
+  ];
+  tpl.templateSpans.forEach((span, i2) => {
     const e = span.expression;
-    pieces.push({ kind: "hole", index: i, start: e.getStart(sf), end: e.getEnd() });
-    pieces.push({ kind: "static", text: span.literal.text, start: span.literal.getStart(sf) + 1 });
+    pieces.push({ kind: "hole", index: i2, start: e.getStart(sf), end: e.getEnd() });
+    pieces.push({
+      kind: "static",
+      text: rawContent(ts, span.literal, sf),
+      start: span.literal.getStart(sf) + 1
+    });
   });
   return pieces;
 }
-function templateAt(ts, sf, pos) {
-  let found;
+
+// src/cache.ts
+var parsed = /* @__PURE__ */ new WeakMap();
+function parseCached(ts, sf, tpl) {
+  let byTemplate = parsed.get(sf);
+  if (!byTemplate) {
+    byTemplate = /* @__PURE__ */ new Map();
+    parsed.set(sf, byTemplate);
+  }
+  const key = tpl.getStart(sf);
+  const hit = byTemplate.get(key);
+  if (hit) return hit;
+  const result = b(templatePieces(ts, tpl, sf));
+  byTemplate.set(key, result);
+  return result;
+}
+var templates = /* @__PURE__ */ new WeakMap();
+function templatesIn(ts, sf) {
+  const hit = templates.get(sf);
+  if (hit) return hit;
+  const found = [];
   const visit = (node) => {
-    if (found) return;
-    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && (node.tag.text === "html" || node.tag.text === "svg") && pos >= node.template.getStart(sf) && pos <= node.template.getEnd()) {
-      found = node;
-      return;
+    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && (node.tag.text === "html" || node.tag.text === "svg")) {
+      found.push(node);
     }
     ts.forEachChild(node, visit);
   };
   visit(sf);
+  found.sort((a2, b2) => a2.getStart(sf) - b2.getStart(sf));
+  templates.set(sf, found);
   return found;
 }
+function templateAtCached(ts, sf, pos) {
+  let match;
+  for (const tpl of templatesIn(ts, sf)) {
+    const start = tpl.template.getStart(sf);
+    if (start > pos) break;
+    if (pos <= tpl.template.getEnd()) match = tpl;
+  }
+  return match;
+}
+
+// ../compiler/dist/resolve/builtins.mjs
+var s = ["Show", "For", "Index", "Switch", "Match", "Portal", "Dynamic", "ErrorBoundary"];
+var i = ["Suspense", "SuspenseList", "Await"];
+var u2 = ["Router", "Outlet", "Redirect", "Link"];
+var p2 = [...s, ...i, ...u2];
+var a = /* @__PURE__ */ new Set([...s, ...i]);
+function l(o = {}) {
+  let { controlFlowModule: e = "@fluixi/dom", coreModule: r = "@fluixi/core", routerModule: c = "@fluixi/core/router-next" } = o, n = {};
+  for (let t of s) n[t] = e;
+  for (let t of i) n[t] = r;
+  for (let t of u2) n[t] = c;
+  return n;
+}
+
+// src/auto-import.ts
+var AUTO_IMPORTED = l();
+var exportsByProgram = /* @__PURE__ */ new WeakMap();
+function moduleExports(ts, program, host, from, moduleName) {
+  let cache2 = exportsByProgram.get(program);
+  if (!cache2) {
+    cache2 = /* @__PURE__ */ new Map();
+    exportsByProgram.set(program, cache2);
+  }
+  if (cache2.has(moduleName)) return cache2.get(moduleName);
+  let symbols;
+  try {
+    const resolved = ts.resolveModuleName(moduleName, from.fileName, program.getCompilerOptions(), host);
+    const file = resolved.resolvedModule && program.getSourceFile(resolved.resolvedModule.resolvedFileName);
+    const checker = program.getTypeChecker();
+    const moduleSymbol = file && checker.getSymbolAtLocation(file);
+    if (moduleSymbol) symbols = checker.getExportsOfModule(moduleSymbol);
+  } catch {
+    symbols = void 0;
+  }
+  cache2.set(moduleName, symbols);
+  return symbols;
+}
+var sitesByProgram = /* @__PURE__ */ new WeakMap();
+function declarationSite(ts, program, host, from, name) {
+  const moduleName = AUTO_IMPORTED[name];
+  if (!moduleName) return void 0;
+  let cache2 = sitesByProgram.get(program);
+  if (!cache2) {
+    cache2 = /* @__PURE__ */ new Map();
+    sitesByProgram.set(program, cache2);
+  }
+  const key = `${moduleName}:${name}`;
+  if (cache2.has(key)) return cache2.get(key);
+  let site;
+  try {
+    const resolved = ts.resolveModuleName(moduleName, from.fileName, program.getCompilerOptions(), host);
+    const entry = resolved.resolvedModule?.resolvedFileName;
+    if (entry) site = findExport(ts, host, program.getCompilerOptions(), entry, name, 0);
+  } catch {
+    site = void 0;
+  }
+  cache2.set(key, site);
+  return site;
+}
+function findExport(ts, host, options, fileName, name, depth) {
+  if (depth > 4) return void 0;
+  const text = host.readFile?.(fileName);
+  if (text === void 0) return void 0;
+  const sf = ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true);
+  const reExports = [];
+  for (const statement of sf.statements) {
+    const declared = declaredName(ts, statement, name);
+    if (declared) {
+      return { fileName, start: declared.getStart(sf), length: declared.getWidth(sf) };
+    }
+    if (ts.isExportDeclaration(statement) && statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) {
+      const specifier = statement.moduleSpecifier.text;
+      if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        const named = statement.exportClause.elements.find((e) => e.name.text === name);
+        if (named) reExports.unshift(specifier);
+      } else if (!statement.exportClause) {
+        reExports.push(specifier);
+      }
+    }
+  }
+  for (const specifier of reExports) {
+    const target = resolveRelative(ts, host, options, fileName, specifier);
+    const found = target && findExport(ts, host, options, target, name, depth + 1);
+    if (found) return found;
+  }
+  return void 0;
+}
+function declaredName(ts, statement, name) {
+  const exported = ts.canHaveModifiers(statement) ? ts.getModifiers(statement)?.some((m2) => m2.kind === ts.SyntaxKind.ExportKeyword) : false;
+  if (!exported) return void 0;
+  if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name?.text === name) {
+    return statement.name;
+  }
+  if (ts.isVariableStatement(statement)) {
+    for (const d of statement.declarationList.declarations) {
+      if (ts.isIdentifier(d.name) && d.name.text === name) return d.name;
+    }
+  }
+  return void 0;
+}
+function resolveRelative(ts, host, options, from, specifier) {
+  if (!specifier.startsWith(".")) return void 0;
+  try {
+    return ts.resolveModuleName(specifier, from, options, host).resolvedModule?.resolvedFileName;
+  } catch {
+    return void 0;
+  }
+}
+function autoImportedSymbol(ts, program, host, from, name) {
+  const moduleName = AUTO_IMPORTED[name];
+  if (!moduleName) return void 0;
+  const symbol = moduleExports(ts, program, host, from, moduleName)?.find((s2) => s2.name === name);
+  if (!symbol) return void 0;
+  if (!(symbol.flags & ts.SymbolFlags.Alias)) return symbol;
+  try {
+    return program.getTypeChecker().getAliasedSymbol(symbol);
+  } catch {
+    return symbol;
+  }
+}
 
 // src/hover.ts
-function componentQuickInfo(ts, ls, fileName, position) {
+function componentQuickInfo(ts, ls, host, fileName, position) {
   const program = ls.getProgram();
   const sf = program?.getSourceFile(fileName);
   if (!program || !sf) return void 0;
-  const template = templateAt(ts, sf, position);
+  const template = templateAtCached(ts, sf, position);
   if (!template) return void 0;
   const hit = componentTagAt(template, sf, position, ts);
   if (!hit) return void 0;
   const checker = program.getTypeChecker();
   const flags = ts.SymbolFlags.Value | ts.SymbolFlags.Function | ts.SymbolFlags.Class | ts.SymbolFlags.Alias;
-  const symbol = checker.getSymbolsInScope(template, flags).find((s) => s.name === hit.name);
+  const symbol = checker.getSymbolsInScope(template, flags).find((s2) => s2.name === hit.name) ?? autoImportedSymbol(ts, program, host, sf, hit.name);
   const decl = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
   if (!decl) return void 0;
-  const namePos = decl.name?.getStart(sf) ?? decl.getStart(sf);
-  const info = ls.getQuickInfoAtPosition(fileName, namePos);
+  const declFile = decl.getSourceFile();
+  const namePos = decl.name?.getStart(declFile) ?? decl.getStart(declFile);
+  const info = ls.getQuickInfoAtPosition(declFile.fileName, namePos);
   if (!info) return void 0;
   return { ...info, textSpan: { start: hit.start, length: hit.name.length } };
 }
 function componentTagAt(template, sf, position, ts) {
-  const { root } = k(templatePieces(ts, template.template, sf));
+  const { root } = parseCached(ts, sf, template.template);
   let hit;
   const walk = (nodes) => {
     for (const node of nodes) {
@@ -584,21 +785,21 @@ function holeRoles(nodes, out) {
   };
   for (const node of nodes) {
     if (node.kind === "Element" || node.kind === "Component") {
-      for (const a of node.attributes) {
-        if (a.kind === "EventBinding") out.set(a.hole, { kind: "event", event: a.name.toLowerCase() });
-        if (node.kind === "Element" && a.kind === "RefBinding") out.set(a.hole, { kind: "refEl", tag: node.tag });
-        if (node.kind === "Element" && a.kind === "UseDirective" && a.hole != null) out.set(a.hole, { kind: "refEl", tag: node.tag });
+      for (const a2 of node.attributes) {
+        if (a2.kind === "EventBinding") out.set(a2.hole, { kind: "event", event: a2.name.toLowerCase() });
+        if (node.kind === "Element" && a2.kind === "RefBinding") out.set(a2.hole, { kind: "refEl", tag: node.tag });
+        if (node.kind === "Element" && a2.kind === "UseDirective" && a2.hole != null) out.set(a2.hole, { kind: "refEl", tag: node.tag });
       }
-      const eachDir = node.attributes.find((a) => a.kind === "EachDirective");
+      const eachDir = node.attributes.find((a2) => a2.kind === "EachDirective");
       if (eachDir && eachDir.kind === "EachDirective") {
         renderChildren(node, { kind: "each", eachHole: eachDir.hole });
       }
       if (node.kind === "Component") {
         const propHole = (name) => {
-          const a = node.attributes.find(
+          const a2 = node.attributes.find(
             (x2) => x2.kind === "Attribute" && x2.name === name && x2.value != null && x2.value.kind === "hole"
           );
-          return a && a.kind === "Attribute" && a.value && a.value.kind === "hole" ? a.value.hole : void 0;
+          return a2 && a2.kind === "Attribute" && a2.value && a2.value.kind === "hole" ? a2.value.hole : void 0;
         };
         const eachHole = propHole("each");
         if (node.tag === "For" && eachHole !== void 0) renderChildren(node, { kind: "each", eachHole });
@@ -611,7 +812,7 @@ function holeRoles(nodes, out) {
   }
 }
 function resolveGlobalType(ts, checker, location, name) {
-  const sym = checker.getSymbolsInScope(location, ts.SymbolFlags.Type).find((s) => s.getName() === name);
+  const sym = checker.getSymbolsInScope(location, ts.SymbolFlags.Type).find((s2) => s2.getName() === name);
   return sym ? checker.getDeclaredTypeOfSymbol(sym) : void 0;
 }
 function resolveElementType(ts, checker, location, tag) {
@@ -621,14 +822,14 @@ function resolveElementType(ts, checker, location, tag) {
   return t ?? resolveGlobalType(ts, checker, location, "HTMLElement");
 }
 function inferParamAt(ts, program, sf, position) {
-  const template = templateAt(ts, sf, position);
+  const template = templateAtCached(ts, sf, position);
   if (!template || ts.isNoSubstitutionTemplateLiteral(template.template)) return void 0;
   const spans = template.template.templateSpans;
-  const holeExprs = spans.map((s) => s.expression);
+  const holeExprs = spans.map((s2) => s2.expression);
   const holeIndex = holeExprs.findIndex((e) => position >= e.getStart(sf) && position <= e.getEnd());
   if (holeIndex === -1) return void 0;
   const roles = /* @__PURE__ */ new Map();
-  holeRoles(k(templatePieces(ts, template.template, sf)).root.children, roles);
+  holeRoles(parseCached(ts, sf, template.template).root.children, roles);
   const role = roles.get(holeIndex);
   if (!role) return void 0;
   const fn = holeExprs[holeIndex];
@@ -639,6 +840,12 @@ function inferParamAt(ts, program, sf, position) {
   const id = identifierAt(ts, sf, position);
   if (!id || id.text !== paramName || !contains(fn, id)) return void 0;
   const checker = program.getTypeChecker();
+  const resolved = typeForRole(ts, checker, fn, role, holeExprs);
+  const { typeText, type } = resolved;
+  if (!typeText) return void 0;
+  return { paramName, typeText, type, start: id.getStart(sf), length: id.getWidth(sf) };
+}
+function typeForRole(ts, checker, fn, role, holeExprs) {
   let typeText;
   let type;
   if (role.kind === "event") {
@@ -659,8 +866,27 @@ function inferParamAt(ts, program, sf, position) {
     type = checker.getTypeAtLocation(holeExprs[role.eachHole]).getNumberIndexType();
     if (type) typeText = checker.typeToString(type);
   }
-  if (!typeText) return void 0;
-  return { paramName, typeText, type, start: id.getStart(sf), length: id.getWidth(sf) };
+  return { typeText, type };
+}
+function inferParamsIn(ts, program, sf) {
+  const checker = program.getTypeChecker();
+  const out = [];
+  for (const template of templatesIn(ts, sf)) {
+    const tpl = template.template;
+    if (ts.isNoSubstitutionTemplateLiteral(tpl)) continue;
+    const holeExprs = tpl.templateSpans.map((s2) => s2.expression);
+    const roles = /* @__PURE__ */ new Map();
+    holeRoles(parseCached(ts, sf, tpl).root.children, roles);
+    for (const [holeIndex, role] of roles) {
+      const fn = holeExprs[holeIndex];
+      if (!fn || !ts.isArrowFunction(fn) && !ts.isFunctionExpression(fn)) continue;
+      const param = fn.parameters[0];
+      if (!param || !ts.isIdentifier(param.name) || param.type) continue;
+      const { type } = typeForRole(ts, checker, fn, role, holeExprs);
+      if (type) out.push({ fn, paramName: param.name.text, type });
+    }
+  }
+  return out;
 }
 function paramQuickInfo(ts, ls, fileName, position) {
   const program = ls.getProgram();
@@ -702,40 +928,39 @@ function contains(outer, inner) {
 }
 
 // src/props.ts
-function componentPropCompletions(ts, ls, fileName, position) {
+function componentPropCompletions(ts, ls, host, fileName, position) {
   const program = ls.getProgram();
   const sf = program?.getSourceFile(fileName);
   if (!program || !sf) return void 0;
-  const template = templateAt(ts, sf, position);
+  const template = templateAtCached(ts, sf, position);
   if (!template) return void 0;
   const comp = componentTagAtAttrArea(ts, sf, template.template, position);
   if (!comp || !comp.tag) return void 0;
+  const span = attrNameSpan(sf.text, position);
   const cf = CONTROL_FLOW_PROPS[comp.tag];
   if (cf) {
     const already2 = new Set(comp.attributeNames);
-    return cf.filter((n) => !already2.has(n)).map((name) => propEntry(ts, name));
+    return cf.filter((n) => !already2.has(n)).map((name) => propEntry(ts, name, span));
   }
   const checker = program.getTypeChecker();
   const rootName = comp.tag.split(".")[0];
-  const decl = findDeclaration(ts, sf, rootName);
-  if (!decl) return void 0;
-  const compType = checker.getTypeAtLocation(decl);
-  const propsType = firstParamType(ts, checker, compType);
+  const compType = componentTypeOf(ts, program, checker, host, sf, template.template, rootName);
+  const propsType = compType && firstParamType(ts, checker, compType);
   if (!propsType) return void 0;
   const already = new Set(comp.attributeNames);
   const entries = [];
-  for (const p2 of propsType.getProperties()) {
-    const name = p2.getName();
+  for (const p3 of propsType.getProperties()) {
+    const name = p3.getName();
     if (name === "children" || already.has(name)) continue;
-    entries.push(propEntry(ts, name));
+    entries.push(propEntry(ts, name, span));
   }
   return entries.length ? entries : void 0;
 }
-function componentPropHover(ts, ls, fileName, position) {
+function componentPropHover(ts, ls, host, fileName, position) {
   const program = ls.getProgram();
   const sf = program?.getSourceFile(fileName);
   if (!program || !sf) return void 0;
-  const template = templateAt(ts, sf, position);
+  const template = templateAtCached(ts, sf, position);
   if (!template) return void 0;
   const hit = propNameAt(ts, sf, template.template, position);
   if (!hit) return void 0;
@@ -746,11 +971,13 @@ function componentPropHover(ts, ls, fileName, position) {
     if (!typeText) return void 0;
   } else if (hit.tag) {
     const checker = program.getTypeChecker();
-    const decl = findDeclaration(ts, sf, hit.tag.split(".")[0]);
-    const propsType = decl && firstParamType(ts, checker, checker.getTypeAtLocation(decl));
+    const root = hit.tag.split(".")[0];
+    const compType = componentTypeOf(ts, program, checker, host, sf, template.template, root);
+    const propsType = compType && firstParamType(ts, checker, compType);
     const sym = propsType && propsType.getProperty(hit.prop);
     if (!sym) return void 0;
-    typeText = checker.typeToString(checker.getTypeOfSymbolAtLocation(sym, sym.valueDeclaration ?? decl));
+    const at = sym.valueDeclaration ?? sym.declarations?.[0] ?? template.template;
+    typeText = checker.typeToString(checker.getTypeOfSymbolAtLocation(sym, at));
   }
   if (!typeText) return void 0;
   return {
@@ -771,16 +998,16 @@ function componentPropHover(ts, ls, fileName, position) {
   };
 }
 function propNameAt(ts, sf, tpl, position) {
-  const { root } = k(templatePieces(ts, tpl, sf));
+  const { root } = parseCached(ts, sf, tpl);
   let hit;
   const walk = (nodes) => {
     for (const node of nodes) {
       if (node.kind === "Component") {
         const c = node;
-        for (const a of c.attributes) {
-          if ((a.kind === "Attribute" || a.kind === "PropertyBinding" || a.kind === "BindDirective") && "loc" in a) {
-            const start = a.loc.start;
-            if (position >= start && position <= start + a.name.length) hit = { tag: c.tag, prop: a.name, start };
+        for (const a2 of c.attributes) {
+          if ((a2.kind === "Attribute" || a2.kind === "PropertyBinding" || a2.kind === "BindDirective") && "loc" in a2) {
+            const start = a2.loc.start;
+            if (position >= start && position <= start + a2.name.length) hit = { tag: c.tag, prop: a2.name, start };
           }
         }
       }
@@ -817,36 +1044,45 @@ var CONTROL_FLOW_PROPS = {
   Dynamic: ["component"],
   Await: ["value", "fallback"]
 };
-function propEntry(ts, name) {
-  return { name, kind: ts.ScriptElementKind.memberVariableElement, kindModifiers: "", sortText: "0_" + name, insertText: name };
-}
-function findDeclaration(ts, sf, name) {
-  for (const stmt of sf.statements) {
-    if ((ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt)) && stmt.name?.text === name) return stmt.name;
-    if (ts.isVariableStatement(stmt)) {
-      for (const d of stmt.declarationList.declarations) {
-        if (ts.isIdentifier(d.name) && d.name.text === name) return d.name;
-      }
-    }
-    if (ts.isImportDeclaration(stmt)) {
-      const b2 = stmt.importClause?.namedBindings;
-      if (b2 && ts.isNamedImports(b2)) {
-        for (const el of b2.elements) if (el.name.text === name) return el.name;
-      }
-      if (stmt.importClause?.name?.text === name) return stmt.importClause.name;
-    }
-  }
-  return void 0;
+function propEntry(ts, name, replacementSpan) {
+  return {
+    name,
+    kind: ts.ScriptElementKind.memberVariableElement,
+    kindModifiers: "",
+    sortText: "0_" + name,
+    insertText: name,
+    // Without a span the editor filters these against whatever word *it* computes at the
+    // cursor, and inside a template literal that is not the attribute name — so the list
+    // showed in full until the first keystroke and then emptied. Saying exactly which
+    // characters are being replaced makes filtering match what is typed.
+    replacementSpan
+  };
+}
+function attrNameSpan(text, position) {
+  const isNameChar = (c) => !!c && /[A-Za-z0-9_$:@?.\-]/.test(c);
+  let start = position;
+  while (start > 0 && isNameChar(text[start - 1])) start--;
+  let end = position;
+  while (end < text.length && isNameChar(text[end])) end++;
+  return { start, length: end - start };
+}
+function componentTypeOf(ts, program, checker, host, sf, template, name) {
+  const flags = ts.SymbolFlags.Value | ts.SymbolFlags.Function | ts.SymbolFlags.Class | ts.SymbolFlags.Alias;
+  const symbol = checker.getSymbolsInScope(template, flags).find((s2) => s2.name === name) ?? autoImportedSymbol(ts, program, host, sf, name);
+  if (!symbol) return void 0;
+  const resolved = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  const decl = resolved.valueDeclaration ?? resolved.declarations?.[0];
+  return decl ? checker.getTypeOfSymbolAtLocation(resolved, decl) : void 0;
 }
 function firstParamType(ts, checker, type) {
   for (const sig of checker.getSignaturesOfType(type, ts.SignatureKind.Call)) {
-    const p2 = sig.getParameters()[0];
-    if (p2) return checker.getTypeOfSymbolAtLocation(p2, p2.valueDeclaration ?? sig.getDeclaration());
+    const p3 = sig.getParameters()[0];
+    if (p3) return checker.getTypeOfSymbolAtLocation(p3, p3.valueDeclaration ?? sig.getDeclaration());
   }
   return void 0;
 }
 function componentTagAtAttrArea(ts, sf, tpl, position) {
-  const { root } = k(templatePieces(ts, tpl, sf));
+  const { root } = parseCached(ts, sf, tpl);
   let hit;
   const walk = (nodes) => {
     for (const node of nodes) {
@@ -854,7 +1090,7 @@ function componentTagAtAttrArea(ts, sf, tpl, position) {
         const c = node;
         const openStart = c.loc.start + 1 + (c.tag ? c.tag.length : 0);
         const openEnd = firstChildOrCloseStart(c);
-        if (position > openStart && position <= openEnd) {
+        if (position > openStart && position < openEnd) {
           hit = { tag: c.tag, attributeNames: attributeNames(c) };
         }
       }
@@ -872,8 +1108,8 @@ function firstChildOrCloseStart(c) {
 }
 function attributeNames(c) {
   const out = [];
-  for (const a of c.attributes) {
-    if (a.kind === "Attribute" || a.kind === "PropertyBinding" || a.kind === "BindDirective") out.push(a.name);
+  for (const a2 of c.attributes) {
+    if (a2.kind === "Attribute" || a2.kind === "PropertyBinding" || a2.kind === "BindDirective") out.push(a2.name);
   }
   return out;
 }
@@ -890,13 +1126,13 @@ function paramMemberCompletions(ts, ls, fileName, position) {
   const checker = program.getTypeChecker();
   const already = /* @__PURE__ */ new Set();
   const entries = [];
-  for (const p2 of checker.getApparentType(info.type).getProperties()) {
-    const name = p2.getName();
+  for (const p3 of checker.getApparentType(info.type).getProperties()) {
+    const name = p3.getName();
     if (already.has(name) || name.startsWith("__")) continue;
     already.add(name);
     entries.push({
       name,
-      kind: memberKind(ts, p2),
+      kind: memberKind(ts, p3),
       kindModifiers: "",
       sortText: "0_" + name,
       insertText: name
@@ -921,366 +1157,450 @@ function propertyAccessAt(ts, sf, position) {
   return found;
 }
 
-// src/virtual.ts
-var EVENT_MAP_KEYS = new Set(Object.keys({
-  click: 0,
-  dblclick: 0,
-  mousedown: 0,
-  mouseup: 0,
-  mousemove: 0,
-  mouseenter: 0,
-  mouseleave: 0,
-  mouseover: 0,
-  mouseout: 0,
-  contextmenu: 0,
-  keydown: 0,
-  keyup: 0,
-  keypress: 0,
-  input: 0,
-  beforeinput: 0,
-  change: 0,
-  submit: 0,
-  focus: 0,
-  blur: 0,
-  focusin: 0,
-  focusout: 0,
-  pointerdown: 0,
-  pointerup: 0,
-  pointermove: 0,
-  pointerenter: 0,
-  pointerleave: 0,
-  wheel: 0,
-  scroll: 0,
-  drag: 0,
-  drop: 0,
-  touchstart: 0,
-  touchend: 0,
-  touchmove: 0,
-  animationend: 0,
-  transitionend: 0
-}));
-var PRELUDE = (
-  // Control-flow component prop types, declared inline so they ALWAYS resolve
-  // (no dependency on @fluixi/core being importable from the virtual document).
-  // Prop shapes drive hover + value checking on when/each/fallback/mount/…;
-  // render-prop children are typed separately by __fxEach/__fxShow.
-  'declare const __fxCF: {\n  Show: <T>(props: { when: T; fallback?: unknown; children?: unknown }) => any;\n  For: <T>(props: { each: readonly T[] | undefined | null; fallback?: unknown; by?: (item: T) => unknown; children?: unknown }) => any;\n  Index: <T>(props: { each: readonly T[] | undefined | null; fallback?: unknown; children?: unknown }) => any;\n  Switch: (props: { fallback?: unknown; children?: unknown }) => any;\n  Match: <T>(props: { when: T; children?: unknown }) => any;\n  Suspense: (props: { fallback?: unknown; children?: unknown }) => any;\n  SuspenseList: (props: { revealOrder: "forwards" | "backwards" | "together"; children?: unknown }) => any;\n  Portal: (props: { mount?: Node; useShadow?: boolean; children?: unknown }) => any;\n  ErrorBoundary: (props: { fallback?: unknown; children?: unknown }) => any;\n  Dynamic: (props: { component: unknown; [k: string]: unknown }) => any;\n  Await: <T>(props: { value: Promise<T> | (() => Promise<T>); fallback?: unknown; children?: unknown }) => any;\n};\ndeclare const __fxEach: <T>(items: ArrayLike<T> | Iterable<T> | null | undefined, render: (item: T, index: () => number) => any) => any;\ndeclare const __fxIndex: <T>(items: ArrayLike<T> | Iterable<T> | null | undefined, render: (item: () => T, index: number) => any) => any;\ndeclare const __fxShow: <T>(when: T, render: (value: NonNullable<T>) => any) => any;\ndeclare const __fxOn: <K extends string>(name: K, handler: (event: K extends keyof HTMLElementEventMap ? HTMLElementEventMap[K] : Event) => any) => any;\ndeclare const __fxRef: <K extends string>(tag: K, ref: (el: K extends keyof HTMLElementTagNameMap ? HTMLElementTagNameMap[K] : HTMLElement) => any) => any;\ndeclare const __fxExpr: (value: any) => any;\ndeclare function __fxProps<P>(comp: (props: P, ...rest: any[]) => any, props: NoInfer<P>): any;\n'
-);
-var CONTROL_FLOW = /* @__PURE__ */ new Set([
-  "Show",
-  "For",
-  "Index",
-  "Switch",
-  "Match",
-  "Dynamic",
-  "ErrorBoundary",
-  "Suspense",
-  "SuspenseList",
-  "Await",
-  "Portal"
-]);
-function inHole(segments, pos) {
-  return segments.some((s) => s.hole && pos >= s.srcStart && pos <= s.srcEnd);
-}
-function inKey(segments, pos) {
-  return segments.some((s) => s.key && pos >= s.srcStart && pos <= s.srcEnd);
-}
-function toGenerated(segments, pos) {
-  for (const s of segments) {
-    if (pos >= s.srcStart && pos <= s.srcEnd) return s.genStart + (pos - s.srcStart);
-  }
-  return -1;
-}
-function toSource(segments, pos) {
-  for (const s of segments) {
-    if (pos >= s.genStart && pos <= s.genEnd) return s.srcStart + (pos - s.genStart);
-  }
-  return -1;
-}
-function buildVirtual(ts, sf) {
-  const templates = collectTemplates(ts, sf);
-  if (templates.length === 0) return void 0;
-  const srcText = sf.text;
-  const segments = [];
-  let gen = "";
-  let src = 0;
-  const copy = (to) => {
-    if (to <= src) return;
-    const genStart = gen.length;
-    gen += srcText.slice(src, to);
-    segments.push({ srcStart: src, srcEnd: to, genStart, genEnd: gen.length });
-    src = to;
+// src/elements.ts
+var ATTRIBUTES_MODULE = "@fluixi/dom/attributes";
+var perProgram = /* @__PURE__ */ new WeakMap();
+function intrinsics(ts, program, host, sf) {
+  const hit = perProgram.get(program);
+  if (hit) return hit;
+  let type;
+  try {
+    const checker = program.getTypeChecker();
+    const declared = (file) => {
+      if (!file) return void 0;
+      const moduleSymbol = checker.getSymbolAtLocation(file);
+      const symbol = moduleSymbol?.exports?.get(ts.escapeLeadingUnderscores("IntrinsicElements"));
+      return symbol ? checker.getDeclaredTypeOfSymbol(symbol) : void 0;
+    };
+    const resolved = ts.resolveModuleName(
+      ATTRIBUTES_MODULE,
+      sf.fileName,
+      program.getCompilerOptions(),
+      host
+    );
+    type = declared(
+      resolved.resolvedModule && program.getSourceFile(resolved.resolvedModule.resolvedFileName)
+    );
+    if (!type) {
+      for (const file of program.getSourceFiles()) {
+        if (file.fileName.indexOf("@fluixi/dom") === -1) continue;
+        type = declared(file);
+        if (type) break;
+      }
+    }
+  } catch {
+    type = void 0;
+  }
+  const entry = { type, byTag: /* @__PURE__ */ new Map() };
+  perProgram.set(program, entry);
+  return entry;
+}
+function attributesFor(ts, program, host, sf, tag) {
+  const state = intrinsics(ts, program, host, sf);
+  if (!state.type) return void 0;
+  if (state.byTag.has(tag)) return state.byTag.get(tag);
+  let props;
+  const checker = program.getTypeChecker();
+  const tagSymbol = state.type.getProperty(tag);
+  if (tagSymbol) {
+    const decl = tagSymbol.valueDeclaration ?? tagSymbol.declarations?.[0];
+    if (decl) props = checker.getTypeOfSymbolAtLocation(tagSymbol, decl).getProperties();
+  }
+  state.byTag.set(tag, props);
+  return props;
+}
+function elementAtAttributeArea(ts, sf, tpl, position) {
+  const { root } = parseCached(ts, sf, tpl);
+  let hit;
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.kind === "Element") {
+        const el = node;
+        const openStart = el.loc.start + 1 + el.tag.length;
+        const openEnd = firstAttributeEnd(el);
+        if (position > openStart && position <= openEnd) {
+          const present = /* @__PURE__ */ new Set();
+          for (const a2 of el.attributes) {
+            if ("loc" in a2 && a2.loc) present.add(writtenName(sf.text, a2.loc.start));
+          }
+          hit = { tag: el.tag, present };
+        }
+      }
+      if (!hit && "children" in node && node.children) walk(node.children);
+      if (hit) return;
+    }
   };
-  gen += PRELUDE;
-  for (const tpl of templates) {
-    copy(tpl.node.getStart(sf));
-    gen = emitTemplate(ts, sf, tpl, gen, segments, srcText);
-    src = tpl.node.getEnd();
+  walk(root.children);
+  return hit;
+}
+function writtenName(text, start) {
+  let end = start;
+  while (end < text.length && !/[\s=/>]/.test(text[end])) end++;
+  return text.slice(start, end);
+}
+function firstAttributeEnd(el) {
+  let end = el.loc.start + 1 + el.tag.length;
+  for (const a2 of el.attributes) {
+    if ("loc" in a2 && a2.loc) end = Math.max(end, a2.loc.end);
   }
-  copy(srcText.length);
-  return { text: gen, segments };
+  return end + 1;
 }
-function isFn(ts, node) {
-  return ts.isArrowFunction(node) || ts.isFunctionExpression(node);
+function elementAttributeCompletions(ts, ls, host, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return void 0;
+  const tpl = templateAtCached(ts, sf, position);
+  if (!tpl) return void 0;
+  const hit = elementAtAttributeArea(ts, sf, tpl.template, position);
+  if (!hit) return void 0;
+  const props = attributesFor(ts, program, host, sf, hit.tag);
+  if (!props) return void 0;
+  const entries = [];
+  for (const p3 of props) {
+    const name = p3.getName();
+    if (name === "children" || hit.present.has(name)) continue;
+    entries.push({
+      name,
+      kind: ts.ScriptElementKind.memberVariableElement,
+      kindModifiers: "",
+      sortText: name.startsWith("on") ? "1" : "0"
+    });
+  }
+  return entries.length ? entries : void 0;
 }
-function collectTemplates(ts, sf) {
-  const out = [];
-  const visit = (node) => {
-    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && (node.tag.text === "html" || node.tag.text === "svg")) {
-      const tpl = node.template;
-      const holes = ts.isTemplateExpression(tpl) ? tpl.templateSpans.map((s) => s.expression) : [];
-      out.push({ node, holes });
+function attributeNameAt(ts, sf, tpl, position) {
+  const { root } = parseCached(ts, sf, tpl);
+  let hit;
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.kind === "Element") {
+        const el = node;
+        for (const a2 of el.attributes) {
+          if (!("loc" in a2) || !a2.loc) continue;
+          const start = a2.loc.start;
+          const name = writtenName(sf.text, start);
+          if (name && position >= start && position <= start + name.length) {
+            hit = { tag: el.tag, name, start };
+          }
+        }
+      }
+      if (!hit && "children" in node && node.children) walk(node.children);
+      if (hit) return;
     }
-    ts.forEachChild(node, visit);
   };
-  visit(sf);
-  return out;
+  walk(root.children);
+  return hit;
 }
-function analyze(nodes, roles, consumed) {
-  const renderChild = (node) => {
-    if (!("children" in node) || !node.children) return void 0;
-    const expr = node.children.find((c) => c.kind === "Expression");
-    return expr && expr.kind === "Expression" ? expr.hole : void 0;
+function elementAttributeHover(ts, ls, host, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return void 0;
+  const tpl = templateAtCached(ts, sf, position);
+  if (!tpl) return void 0;
+  const hit = attributeNameAt(ts, sf, tpl.template, position);
+  if (!hit) return void 0;
+  const props = attributesFor(ts, program, host, sf, hit.tag);
+  const symbol = props?.find((p3) => p3.getName() === hit.name);
+  if (!symbol) return void 0;
+  const decl = symbol.valueDeclaration ?? symbol.declarations?.[0];
+  if (!decl) return void 0;
+  const checker = program.getTypeChecker();
+  const typeText = checker.typeToString(checker.getTypeOfSymbolAtLocation(symbol, decl));
+  return {
+    kind: ts.ScriptElementKind.memberVariableElement,
+    kindModifiers: "",
+    textSpan: { start: hit.start, length: hit.name.length },
+    displayParts: [
+      { text: "(", kind: "punctuation" },
+      { text: "attribute", kind: "text" },
+      { text: ")", kind: "punctuation" },
+      { text: " ", kind: "space" },
+      { text: `${hit.tag}.`, kind: "text" },
+      { text: hit.name, kind: "propertyName" },
+      { text: ":", kind: "punctuation" },
+      { text: " ", kind: "space" },
+      { text: typeText, kind: "text" }
+    ],
+    documentation: symbol.getDocumentationComment(checker)
   };
-  for (const node of nodes) {
-    if (node.kind === "Element" || node.kind === "Component") {
-      for (const a of node.attributes) {
-        if (a.kind === "EventBinding") roles.set(a.hole, { kind: "event", event: a.name.toLowerCase() });
-        if (a.kind === "RefBinding" && node.kind === "Element") roles.set(a.hole, { kind: "ref", tag: node.tag });
-        if (a.kind === "UseDirective" && a.hole != null && node.kind === "Element") roles.set(a.hole, { kind: "ref", tag: node.tag });
-      }
-      const eachDir = node.attributes.find((a) => a.kind === "EachDirective");
-      const propHole = (name) => {
-        const a = node.attributes.find(
-          (x2) => x2.kind === "Attribute" && x2.name === name && x2.value != null && x2.value.kind === "hole"
-        );
-        return a && a.kind === "Attribute" && a.value && a.value.kind === "hole" ? a.value.hole : void 0;
-      };
-      const wire = (arrayHole, kind) => {
-        const r = renderChild(node);
-        if (r !== void 0) {
-          roles.set(r, { kind, arrayHole });
-          consumed.add(arrayHole);
-        }
-      };
-      if (eachDir && eachDir.kind === "EachDirective") wire(eachDir.hole, "eachRender");
-      else if (node.kind === "Component" && node.tag === "For") {
-        const h = propHole("each");
-        if (h !== void 0) wire(h, "eachRender");
-      } else if (node.kind === "Component" && node.tag === "Index") {
-        const h = propHole("each");
-        if (h !== void 0) wire(h, "indexRender");
-      } else if (node.kind === "Component" && node.tag === "Show") {
-        const w = propHole("when");
-        const r = renderChild(node);
-        if (w !== void 0 && r !== void 0) {
-          roles.set(r, { kind: "showRender", whenHole: w });
-          consumed.add(w);
+}
+
+// src/diagnostics.ts
+var ACCESSOR_NOT_CALLED = 9001;
+function acceptsAnyProperty(ts, checker, type) {
+  const open = ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter | ts.TypeFlags.Never;
+  if (type.flags & open) return true;
+  if (checker.getIndexInfoOfType?.(type, ts.IndexKind.String)) return true;
+  if (type.isUnion()) return type.types.some((t) => acceptsAnyProperty(ts, checker, t));
+  return false;
+}
+function accessorDiagnostics(ts, program, sf) {
+  const checker = program.getTypeChecker();
+  const out = [];
+  for (const template of templatesIn(ts, sf)) {
+    const tpl = template.template;
+    if (ts.isNoSubstitutionTemplateLiteral(tpl)) continue;
+    const holes = tpl.templateSpans.map((s2) => s2.expression);
+    const visit = (nodes, parent) => {
+      for (const node of nodes) {
+        if (node.kind === "Expression" && parent?.kind === "Element") {
+          const expression = holes[node.hole];
+          if (expression && isAccessorRead(ts, expression) && isAccessor(ts, checker, expression)) {
+            const text = expression.getText(sf);
+            out.push({
+              file: sf,
+              start: expression.getStart(sf),
+              length: expression.getWidth(sf),
+              category: ts.DiagnosticCategory.Warning,
+              code: ACCESSOR_NOT_CALLED,
+              messageText: `'${text}' is an accessor \u2014 call it (\`${text}()\`). Left bare it renders the function and never updates.`,
+              source: "fluixi"
+            });
+          }
         }
+        const children = "children" in node ? node.children : void 0;
+        if (children) visit(children, node);
       }
-    }
-    if ("children" in node && node.children) analyze(node.children, roles, consumed);
+    };
+    visit(parseCached(ts, sf, tpl).root.children, null);
   }
+  return out;
 }
-function emitTemplate(ts, sf, tpl, gen, segments, srcText) {
-  const roles = /* @__PURE__ */ new Map();
-  const consumed = /* @__PURE__ */ new Set();
-  const { root } = k(templatePieces(ts, tpl.node.template, sf));
-  analyze(root.children, roles, consumed);
-  const holeSrc = (i) => [tpl.holes[i].getStart(sf), tpl.holes[i].getEnd()];
-  const putHole = (i) => {
-    const [s, e] = holeSrc(i);
-    const genStart = gen.length;
-    gen += srcText.slice(s, e);
-    segments.push({ srcStart: s, srcEnd: e, genStart, genEnd: gen.length, hole: true });
-  };
-  const isIdent = (t) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(t);
-  const putKey = (start, text) => {
-    const genStart = gen.length;
-    if (isIdent(text)) {
-      gen += text;
-      segments.push({ srcStart: start, srcEnd: start + text.length, genStart, genEnd: gen.length, key: true });
-    } else {
-      gen += JSON.stringify(text);
-    }
-  };
-  const calls = [];
-  const walkComponents = (nodes) => {
-    for (const node of nodes) {
-      if (node.kind === "Component") calls.push(componentPropsEmitter(node));
-      if ("children" in node && node.children) walkComponents(node.children);
-    }
-  };
-  function componentPropsEmitter(node) {
-    return () => {
-      gen += "__fxProps(";
-      if (node.tagHole != null) putHole(node.tagHole);
-      else if (CONTROL_FLOW.has(node.tag)) gen += `__fxCF.${node.tag}`;
-      else gen += node.tag;
-      gen += ", { ";
-      let first = true;
-      const entry = (keyStart, keyText, emitValue) => {
-        if (!first) gen += ", ";
-        first = false;
-        putKey(keyStart, keyText);
-        gen += ": ";
-        emitValue();
-      };
-      for (const a of node.attributes) {
-        if (a.kind === "Attribute") {
-          const keyStart = a.boolean ? a.loc.start + 1 : a.loc.start;
-          const v2 = a.value;
-          entry(keyStart, a.name, () => {
-            if (!v2) {
-              gen += "true";
-            } else if (v2.kind === "static") {
-              gen += JSON.stringify(v2.value);
-            } else if (v2.kind === "hole") {
-              putHole(v2.hole);
-            } else {
-              gen += "undefined as any";
-            }
+function isAccessorRead(ts, node) {
+  return ts.isIdentifier(node) || ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node);
+}
+function isAccessor(ts, checker, node) {
+  const signatures = checker.getTypeAtLocation(node).getCallSignatures();
+  if (signatures.length !== 1) return false;
+  const signature = signatures[0];
+  if (signature.getParameters().some((p3) => !isOptional(ts, p3))) return false;
+  const returned = signature.getReturnType();
+  return !(returned.flags & (ts.TypeFlags.Void | ts.TypeFlags.Never));
+}
+function isOptional(ts, symbol) {
+  const declaration = symbol.valueDeclaration;
+  return !!declaration && ts.isParameter(declaration) && (!!declaration.questionToken || !!declaration.initializer || !!declaration.dotDotDotToken);
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function templateDiagnostics(ts, ls, fileName) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return [];
+  const hit = cache.get(sf);
+  if (hit) return hit;
+  const checker = program.getTypeChecker();
+  const out = [];
+  out.push(...accessorDiagnostics(ts, program, sf));
+  for (const { fn, paramName, type } of inferParamsIn(ts, program, sf)) {
+    if (acceptsAnyProperty(ts, checker, type)) continue;
+    const visit = (node) => {
+      if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === paramName && ts.isIdentifier(node.name)) {
+        const symbol = checker.getSymbolAtLocation(node.expression);
+        const declaredHere = symbol?.declarations?.some((d) => d.parent === fn);
+        if (declaredHere && !checker.getPropertyOfType(type, node.name.text)) {
+          out.push({
+            file: sf,
+            start: node.name.getStart(sf),
+            length: node.name.getWidth(sf),
+            category: ts.DiagnosticCategory.Error,
+            code: 2339,
+            messageText: `Property '${node.name.text}' does not exist on type '${checker.typeToString(type)}'.`,
+            source: "fluixi"
           });
-        } else if (a.kind === "PropertyBinding") {
-          entry(a.loc.start + 1, a.name, () => putHole(a.hole));
         }
       }
-      gen += " })";
+      ts.forEachChild(node, visit);
     };
+    if (fn.body) visit(fn.body);
   }
-  walkComponents(root.children);
-  for (let i = 0; i < tpl.holes.length; i++) {
-    if (consumed.has(i)) continue;
-    const role = roles.get(i);
-    if (role && role.kind === "eachRender") {
-      calls.push(() => {
-        gen += "__fxEach(";
-        putHole(role.arrayHole);
-        gen += ", ";
-        putHole(i);
-        gen += ")";
-      });
-    } else if (role && role.kind === "indexRender") {
-      calls.push(() => {
-        gen += "__fxIndex(";
-        putHole(role.arrayHole);
-        gen += ", ";
-        putHole(i);
-        gen += ")";
-      });
-    } else if (role && role.kind === "showRender") {
-      calls.push(() => {
-        gen += "__fxShow(";
-        putHole(role.whenHole);
-        gen += ", ";
-        putHole(i);
-        gen += ")";
-      });
-    } else if (role && role.kind === "event") {
-      const key = EVENT_MAP_KEYS.has(role.event) ? role.event : role.event;
-      calls.push(() => {
-        gen += `__fxOn(${JSON.stringify(key)}, `;
-        putHole(i);
-        gen += ")";
-      });
-    } else if (role && role.kind === "ref" && isFn(ts, tpl.holes[i])) {
-      const tag = role.tag;
-      calls.push(() => {
-        gen += `__fxRef(${JSON.stringify(tag)}, `;
-        putHole(i);
-        gen += ")";
-      });
-    } else {
-      calls.push(() => {
-        gen += "__fxExpr(";
-        putHole(i);
-        gen += ")";
-      });
-    }
-  }
-  gen += "(";
-  calls.forEach((emit, idx) => {
-    if (idx > 0) gen += ", ";
-    emit();
-  });
-  gen += calls.length > 0 ? ", undefined as any)" : "undefined as any)";
-  return gen;
+  cache.set(sf, out);
+  return out;
 }
 
-// src/virtual-service.ts
-var VirtualService = class {
-  constructor(ts, host) {
-    this.ts = ts;
-    this.host = host;
-    const self = this;
-    const virtualHost = new Proxy(host, {
-      get(target, prop, receiver) {
-        if (prop === "getScriptSnapshot") {
-          return (fileName) => {
-            const v2 = self.virtual(fileName);
-            return v2 ? self.ts.ScriptSnapshot.fromString(v2.text) : target.getScriptSnapshot(fileName);
-          };
+// src/fixes.ts
+function templateCodeFixes(ts, ls, fileName, start, end, errorCodes) {
+  if (!errorCodes.includes(ACCESSOR_NOT_CALLED)) return [];
+  const out = [];
+  for (const diagnostic of templateDiagnostics(ts, ls, fileName)) {
+    if (diagnostic.code !== ACCESSOR_NOT_CALLED || diagnostic.start === void 0) continue;
+    if (diagnostic.start > end || diagnostic.start + (diagnostic.length ?? 0) < start) continue;
+    const at = diagnostic.start + (diagnostic.length ?? 0);
+    const name = diagnostic.file?.text.slice(diagnostic.start, at) ?? "value";
+    out.push({
+      fixName: "fluixiCallAccessor",
+      description: `Call '${name}'`,
+      changes: [
+        {
+          fileName,
+          textChanges: [{ span: { start: at, length: 0 }, newText: "()" }]
         }
-        const value = Reflect.get(target, prop, receiver);
-        return typeof value === "function" ? value.bind(target) : value;
-      }
+      ],
+      // Every occurrence in the file is the same edit, so offer to do them at once.
+      fixAllDescription: "Call every uncalled accessor in this file"
     });
-    this.ls = ts.createLanguageService(virtualHost, ts.createDocumentRegistry());
-  }
-  ls;
-  /** Cached per file: the virtual text + segments, keyed by the file's version. */
-  cache = /* @__PURE__ */ new Map();
-  /** The virtual doc for a file (built + cached per source version), if it has templates. */
-  virtual(fileName) {
-    const version = this.host.getScriptVersion(fileName);
-    const hit = this.cache.get(fileName);
-    if (hit && hit.version === version) return hit.text ? hit : void 0;
-    const snap = this.host.getScriptSnapshot(fileName);
-    if (!snap) return void 0;
-    const src = snap.getText(0, snap.getLength());
-    const sf = this.ts.createSourceFile(fileName, src, this.ts.ScriptTarget.Latest, true, scriptKind(this.ts, fileName));
-    const v2 = buildVirtual(this.ts, sf);
-    this.cache.set(fileName, { version, text: v2?.text ?? "", segments: v2?.segments ?? [] });
-    return v2;
-  }
-  segmentsFor(fileName) {
-    return this.virtual(fileName)?.segments;
-  }
-  service() {
-    return this.ls;
-  }
-  toGen(fileName, pos) {
-    const segs = this.virtual(fileName)?.segments;
-    return segs ? toGenerated(segs, pos) : -1;
-  }
-  toSrc(fileName, pos) {
-    const segs = this.virtual(fileName)?.segments;
-    return segs ? toSource(segs, pos) : -1;
-  }
-  /** True when a SOURCE position lies inside an embedded `${…}` hole. */
-  inHole(fileName, pos) {
-    const segs = this.virtual(fileName)?.segments;
-    return segs ? inHole(segs, pos) : false;
-  }
-  /** True when a SOURCE position lies on a mapped component prop-name key. */
-  inKey(fileName, pos) {
-    const segs = this.virtual(fileName)?.segments;
-    return segs ? inKey(segs, pos) : false;
   }
-};
-function scriptKind(ts, fileName) {
-  if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
-  if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
-  if (fileName.endsWith(".js") || fileName.endsWith(".mjs") || fileName.endsWith(".cjs")) return ts.ScriptKind.JS;
-  return ts.ScriptKind.TS;
+  return out;
+}
+function templateFixAll(ts, ls, fileName, errorCodes) {
+  if (!errorCodes.includes(ACCESSOR_NOT_CALLED)) return void 0;
+  const textChanges = [];
+  for (const diagnostic of templateDiagnostics(ts, ls, fileName)) {
+    if (diagnostic.code !== ACCESSOR_NOT_CALLED || diagnostic.start === void 0) continue;
+    const at = diagnostic.start + (diagnostic.length ?? 0);
+    textChanges.push({ span: { start: at, length: 0 }, newText: "()" });
+  }
+  if (textChanges.length === 0) return void 0;
+  textChanges.sort((a2, b2) => b2.span.start - a2.span.start);
+  return { changes: [{ fileName, textChanges }], commands: void 0 };
 }
 
-// src/bridge.ts
-function mapDiagnostic(vs, fileName, d) {
-  if (d.start === void 0) return d;
-  const start = vs.toSrc(fileName, d.start);
-  if (start === -1) return void 0;
-  return { ...d, start };
+// src/navigation.ts
+var spansByFile = /* @__PURE__ */ new WeakMap();
+function tagSpans(ts, sf) {
+  const hit = spansByFile.get(sf);
+  if (hit) return hit;
+  const out = [];
+  for (const template of templatesIn(ts, sf)) {
+    const { root } = parseCached(ts, sf, template.template);
+    const walk = (nodes) => {
+      for (const node of nodes) {
+        if (node.kind === "Component" && node.tag) {
+          const component = node;
+          const name = component.tag.split(".")[0];
+          out.push({ name, start: component.loc.start + 1, length: name.length });
+          const closing = closingTagName(sf.text, component.loc.end, component.tag);
+          if (closing !== void 0) out.push({ name, start: closing, length: name.length });
+        }
+        if ("children" in node && node.children) walk(node.children);
+      }
+    };
+    walk(root.children);
+  }
+  spansByFile.set(sf, out);
+  return out;
+}
+function closingTagName(text, end, tag) {
+  const open = text.lastIndexOf("</", end);
+  if (open === -1) return void 0;
+  const close = text.indexOf(">", open);
+  if (close === -1 || close >= end) return void 0;
+  const index = text.indexOf(tag, open);
+  return index !== -1 && index < close ? index : void 0;
+}
+function tagAt(ts, sf, position) {
+  if (!templateAtCached(ts, sf, position)) return void 0;
+  return tagSpans(ts, sf).find((s2) => position >= s2.start && position <= s2.start + s2.length);
+}
+function symbolFor(ts, program, host, location, name) {
+  const checker = program.getTypeChecker();
+  const flags = ts.SymbolFlags.Value | ts.SymbolFlags.Function | ts.SymbolFlags.Class | ts.SymbolFlags.Alias;
+  const symbol = checker.getSymbolsInScope(location, flags).find((s2) => s2.name === name);
+  if (!symbol) return autoImportedSymbol(ts, program, host, location.getSourceFile(), name);
+  return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+}
+function declarationFor(ts, program, host, sf, tag) {
+  const template = templateAtCached(ts, sf, tag.start);
+  if (!template) return void 0;
+  const symbol = symbolFor(ts, program, host, template, tag.name);
+  return symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+}
+function templateDefinition(ts, ls, host, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return void 0;
+  const tag = tagAt(ts, sf, position);
+  if (!tag) return void 0;
+  const decl = declarationFor(ts, program, host, sf, tag);
+  if (!decl) {
+    const site = declarationSite(ts, program, host, sf, tag.name);
+    if (!site) return void 0;
+    return [
+      {
+        fileName: site.fileName,
+        textSpan: { start: site.start, length: site.length },
+        kind: ts.ScriptElementKind.unknown,
+        name: tag.name,
+        containerKind: ts.ScriptElementKind.unknown,
+        containerName: ""
+      }
+    ];
+  }
+  const target = decl.name ?? decl;
+  const declFile = decl.getSourceFile();
+  return [
+    {
+      fileName: declFile.fileName,
+      textSpan: { start: target.getStart(declFile), length: target.getWidth(declFile) },
+      kind: ts.ScriptElementKind.unknown,
+      name: tag.name,
+      containerKind: ts.ScriptElementKind.unknown,
+      containerName: ""
+    }
+  ];
+}
+function tagOccurrences(ts, program, host, symbol, name) {
+  const out = [];
+  for (const sf of program.getSourceFiles()) {
+    if (sf.isDeclarationFile) continue;
+    const text = sf.text;
+    if (text.indexOf("html`") === -1 && text.indexOf("svg`") === -1) continue;
+    if (text.indexOf(name) === -1) continue;
+    for (const span of tagSpans(ts, sf)) {
+      if (span.name !== name) continue;
+      const template = templateAtCached(ts, sf, span.start);
+      if (!template || symbolFor(ts, program, host, template, name) !== symbol) continue;
+      out.push({ fileName: sf.fileName, span: { start: span.start, length: span.length } });
+    }
+  }
+  return out;
+}
+function symbolAt(ts, program, host, sf, position) {
+  const checker = program.getTypeChecker();
+  const tag = tagAt(ts, sf, position);
+  if (tag) {
+    const template = templateAtCached(ts, sf, tag.start);
+    const symbol2 = template && symbolFor(ts, program, host, template, tag.name);
+    return symbol2 ? { symbol: symbol2, name: tag.name } : void 0;
+  }
+  const token = tokenAt(ts, sf, position);
+  if (!token || !ts.isIdentifier(token)) return void 0;
+  let symbol = checker.getSymbolAtLocation(token);
+  if (symbol && symbol.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
+  return symbol ? { symbol, name: token.text } : void 0;
+}
+function tokenAt(ts, sf, position) {
+  let found;
+  const visit = (node) => {
+    if (position < node.getStart(sf) || position > node.getEnd()) return;
+    if (node.getChildCount(sf) === 0) found = node;
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return found;
+}
+function templateReferences(ts, ls, host, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return [];
+  const hit = symbolAt(ts, program, host, sf, position);
+  if (!hit) return [];
+  return tagOccurrences(ts, program, host, hit.symbol, hit.name).map(({ fileName: f2, span }) => ({
+    fileName: f2,
+    textSpan: span,
+    isWriteAccess: false,
+    isDefinition: false
+  }));
+}
+function templateRenameLocations(ts, ls, host, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return [];
+  const hit = symbolAt(ts, program, host, sf, position);
+  if (!hit) return [];
+  return tagOccurrences(ts, program, host, hit.symbol, hit.name).map(({ fileName: f2, span }) => ({
+    fileName: f2,
+    textSpan: span
+  }));
 }
 
 // src/index.ts
@@ -1289,12 +1609,7 @@ function init(modules) {
   return {
     create(info) {
       const ls = info.languageService;
-      let vs;
-      try {
-        vs = new VirtualService(ts, info.languageServiceHost);
-      } catch {
-        vs = void 0;
-      }
+      const host = info.languageServiceHost;
       const proxy = /* @__PURE__ */ Object.create(null);
       for (const key of Object.keys(ls)) {
         const member = ls[key];
@@ -1304,9 +1619,24 @@ function init(modules) {
         isGlobalCompletion: false,
         isMemberCompletion: false,
         isNewIdentifierLocation: true,
+        // Re-ask on every keystroke instead of letting the editor filter what it already
+        // has. Inside a template the valid set changes with the cursor — a tag name, then
+        // that tag's props — and a list cached from one position is wrong at the next.
+        // Without this the props appear only after enough typing to force a fresh
+        // request, which reads as completion working intermittently.
+        isIncomplete: true,
         entries
       });
       const IMPLICIT_ANY = /* @__PURE__ */ new Set([7006, 7044]);
+      const dedupe = (items) => {
+        const seen = /* @__PURE__ */ new Set();
+        return items.filter((i2) => {
+          const key = `${i2.fileName}:${i2.textSpan.start}:${i2.textSpan.length}`;
+          if (seen.has(key)) return false;
+          seen.add(key);
+          return true;
+        });
+      };
       const reliableFilter = (fileName, diagnostics) => {
         const program = ls.getProgram();
         const sourceFile = program?.getSourceFile(fileName);
@@ -1318,47 +1648,49 @@ function init(modules) {
           return true;
         });
       };
-      const holeDiagnostics = (fileName, get) => {
-        if (!vs || !vs.segmentsFor(fileName)) return [];
+      proxy.getSemanticDiagnostics = (fileName) => {
+        const base = reliableFilter(fileName, ls.getSemanticDiagnostics(fileName));
         try {
-          const sourceFile = ls.getProgram()?.getSourceFile(fileName);
-          const out = [];
-          for (const d of get(fileName)) {
-            if (d.start === void 0) continue;
-            const m2 = mapDiagnostic(vs, fileName, d);
-            if (m2 && m2.start !== void 0 && (vs.inHole(fileName, m2.start) || vs.inKey(fileName, m2.start))) {
-              out.push({ ...m2, file: sourceFile });
-            }
-          }
-          return out;
+          return base.concat(templateDiagnostics(ts, ls, fileName));
         } catch {
-          return [];
+          return base;
         }
       };
-      proxy.getSemanticDiagnostics = (fileName) => {
-        const base = reliableFilter(fileName, ls.getSemanticDiagnostics(fileName));
-        return base.concat(holeDiagnostics(fileName, (f) => vs.service().getSemanticDiagnostics(f)));
-      };
       proxy.getSuggestionDiagnostics = (fileName) => reliableFilter(fileName, ls.getSuggestionDiagnostics(fileName));
       proxy.getQuickInfoAtPosition = (fileName, position) => {
         try {
-          const prop = componentPropHover(ts, ls, fileName, position);
+          const prop = componentPropHover(ts, ls, host, fileName, position);
           if (prop) return prop;
         } catch {
         }
+        try {
+          const attr = elementAttributeHover(ts, ls, host, fileName, position);
+          if (attr) return attr;
+        } catch {
+        }
         try {
           const inferred = paramQuickInfo(ts, ls, fileName, position);
           if (inferred) return inferred;
         } catch {
         }
-        return ls.getQuickInfoAtPosition(fileName, position) ?? componentQuickInfo(ts, ls, fileName, position);
+        try {
+          const tag = componentQuickInfo(ts, ls, host, fileName, position);
+          if (tag) return tag;
+        } catch {
+        }
+        return ls.getQuickInfoAtPosition(fileName, position);
       };
       proxy.getCompletionsAtPosition = (fileName, position, options, formatting) => {
         try {
-          const props = componentPropCompletions(ts, ls, fileName, position);
+          const props = componentPropCompletions(ts, ls, host, fileName, position);
           if (props) return completionList(props);
         } catch {
         }
+        try {
+          const attrs = elementAttributeCompletions(ts, ls, host, fileName, position);
+          if (attrs) return completionList(attrs);
+        } catch {
+        }
         try {
           const members = paramMemberCompletions(ts, ls, fileName, position);
           if (members) return completionList(members);
@@ -1366,6 +1698,71 @@ function init(modules) {
         }
         return ls.getCompletionsAtPosition(fileName, position, options, formatting);
       };
+      proxy.getDefinitionAtPosition = (fileName, position) => {
+        try {
+          const tag = templateDefinition(ts, ls, host, fileName, position);
+          if (tag) return tag;
+        } catch {
+        }
+        return ls.getDefinitionAtPosition(fileName, position);
+      };
+      proxy.getDefinitionAndBoundSpan = (fileName, position) => {
+        try {
+          const definitions = templateDefinition(ts, ls, host, fileName, position);
+          if (definitions) {
+            const sf = ls.getProgram()?.getSourceFile(fileName);
+            const tag = sf && tagAt(ts, sf, position);
+            if (tag) {
+              return { definitions, textSpan: { start: tag.start, length: tag.length } };
+            }
+          }
+        } catch {
+        }
+        return ls.getDefinitionAndBoundSpan(fileName, position);
+      };
+      proxy.getReferencesAtPosition = (fileName, position) => {
+        const base = ls.getReferencesAtPosition(fileName, position) ?? [];
+        try {
+          const extra = templateReferences(ts, ls, host, fileName, position);
+          return extra.length ? dedupe([...base, ...extra]) : base;
+        } catch {
+          return base;
+        }
+      };
+      proxy.findRenameLocations = (fileName, position, findInStrings, findInComments, prefs) => {
+        const base = ls.findRenameLocations(fileName, position, findInStrings, findInComments, prefs) ?? [];
+        try {
+          const extra = templateRenameLocations(ts, ls, host, fileName, position);
+          if (!base.length || !extra.length) return base.length ? base : void 0;
+          return dedupe([...base, ...extra]);
+        } catch {
+          return base;
+        }
+      };
+      proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences) => {
+        const base = ls.getCodeFixesAtPosition(
+          fileName,
+          start,
+          end,
+          errorCodes,
+          formatOptions,
+          preferences
+        );
+        try {
+          const own = templateCodeFixes(ts, ls, fileName, start, end, errorCodes);
+          return own.length ? [...base, ...own] : base;
+        } catch {
+          return base;
+        }
+      };
+      proxy.getCombinedCodeFix = (scope, fixId, formatOptions, preferences) => {
+        if (fixId === "fluixiCallAccessor") {
+          const fileName = scope.fileName;
+          const combined = templateFixAll(ts, ls, fileName, [ACCESSOR_NOT_CALLED]);
+          if (combined) return combined;
+        }
+        return ls.getCombinedCodeFix(scope, fixId, formatOptions, preferences);
+      };
       return proxy;
     }
   };