@fluixi/ts-plugin 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/index.js

@@ -1,37 +1,41 @@
 "use strict";
 
 // ../template-parser/dist/index.mjs
-function x(e) {
-  let t = (i2, n) => {
-    i2.parent = n;
-    let r = R(i2);
-    for (let s2 of r) t(s2, i2);
+function setParents(root) {
+  const visit = (node, parent) => {
+    node.parent = parent;
+    const kids = childrenOf(node);
+    for (const child of kids) visit(child, node);
   };
-  return t(e, null), e;
+  visit(root, null);
+  return root;
 }
-function R(e) {
-  switch (e.kind) {
+function childrenOf(node) {
+  switch (node.kind) {
     case "Root":
     case "Element":
     case "Component":
     case "Fragment":
-      return e.children;
+      return node.children;
     default:
       return [];
   }
 }
-var m = class {
-  constructor(t) {
-    this.pieces = t;
+var Reader = class {
+  // offset within the current static piece
+  constructor(pieces) {
+    this.pieces = pieces;
     this.pi = 0;
     this.oi = 0;
     this.normalize();
   }
+  /** Skip fully-consumed static pieces so `current()` is live text or a hole. */
   normalize() {
-    for (; this.pi < this.pieces.length; ) {
-      let t = this.pieces[this.pi];
-      if (t.kind === "static" && this.oi >= t.text.length) {
-        this.pi++, this.oi = 0;
+    while (this.pi < this.pieces.length) {
+      const p = this.pieces[this.pi];
+      if (p.kind === "static" && this.oi >= p.text.length) {
+        this.pi++;
+        this.oi = 0;
         continue;
       }
       break;
@@ -40,174 +44,449 @@ var m = class {
   eof() {
     return this.pi >= this.pieces.length;
   }
+  /** Absolute source offset of the cursor. */
   pos() {
     if (this.eof()) {
-      let i2 = this.pieces[this.pieces.length - 1];
-      return i2 ? i2.kind === "static" ? i2.start + i2.text.length : i2.end : 0;
+      const last = this.pieces[this.pieces.length - 1];
+      return last ? last.kind === "static" ? last.start + last.text.length : last.end : 0;
     }
-    let t = this.pieces[this.pi];
-    return t.kind === "static" ? t.start + this.oi : t.start;
+    const p = this.pieces[this.pi];
+    return p.kind === "static" ? p.start + this.oi : p.start;
   }
+  /** True when the cursor sits exactly on a hole marker. */
   atHole() {
     return !this.eof() && this.pieces[this.pi].kind === "hole";
   }
+  /** True when advancing one char would land on a hole (e.g. the `<` in `<${Tag}`). */
   holeFollows() {
     if (this.eof()) return false;
-    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";
+    const p = this.pieces[this.pi];
+    if (p.kind !== "static") return false;
+    if (this.oi + 1 < p.text.length) return false;
+    const next = this.pieces[this.pi + 1];
+    return next !== void 0 && next.kind === "hole";
   }
+  /** Consume the hole at the cursor. Caller must have checked {@link atHole}. */
   takeHole() {
-    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 } };
+    const p = this.pieces[this.pi];
+    if (p.kind !== "hole") throw new Error("takeHole called off a hole");
+    this.pi++;
+    this.oi = 0;
+    this.normalize();
+    return { index: p.index, loc: { start: p.start, end: p.end } };
   }
-  peek(t = 0) {
+  /** Char `k` ahead within the current static segment, or '' at a boundary/hole. */
+  peek(k = 0) {
     if (this.eof()) return "";
-    let i2 = this.pieces[this.pi];
-    return i2.kind !== "static" ? "" : i2.text[this.oi + t] ?? "";
+    const p = this.pieces[this.pi];
+    if (p.kind !== "static") return "";
+    return p.text[this.oi + k] ?? "";
   }
-  startsWith(t) {
+  /** Whether the current static segment starts with `s` at the cursor. */
+  startsWith(s) {
     if (this.eof()) return false;
-    let i2 = this.pieces[this.pi];
-    return i2.kind !== "static" ? false : i2.text.startsWith(t, this.oi);
+    const p = this.pieces[this.pi];
+    if (p.kind !== "static") return false;
+    return p.text.startsWith(s, this.oi);
   }
+  /** Advance one character inside the current static segment. */
   advance() {
     if (this.eof()) return "";
-    let t = this.pieces[this.pi];
-    if (t.kind !== "static") return "";
-    let i2 = t.text[this.oi++] ?? "";
-    return this.normalize(), i2;
-  }
-  readWhile(t) {
-    let i2 = "";
-    for (; !this.eof() && !this.atHole(); ) {
-      let n = this.peek();
-      if (n === "" || !t(n)) break;
-      i2 += n, this.oi++;
+    const p = this.pieces[this.pi];
+    if (p.kind !== "static") return "";
+    const ch = p.text[this.oi++] ?? "";
+    this.normalize();
+    return ch;
+  }
+  /** Advance while `pred` holds and we stay inside one static segment. */
+  readWhile(pred) {
+    let out = "";
+    while (!this.eof() && !this.atHole()) {
+      const ch = this.peek();
+      if (ch === "" || !pred(ch)) break;
+      out += ch;
+      this.oi++;
     }
-    return this.normalize(), i2;
+    this.normalize();
+    return out;
   }
   skipWhitespace() {
-    this.readWhile((t) => /\s/.test(t));
+    this.readWhile((ch) => /\s/.test(ch));
   }
-  span(t) {
-    return { start: t, end: this.pos() };
+  span(start) {
+    return { start, end: this.pos() };
   }
 };
-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);
+var EVENT_MODIFIERS = /* @__PURE__ */ new Set(["capture", "once", "passive", "prevent", "stop", "self"]);
+function requireHole(raw, what) {
+  if (raw.value && raw.value.kind === "hole") return raw.value.hole;
+  raw.report("invalid-binding", `${what} requires an expression value: ${raw.name}=\${\u2026}`);
+  return -1;
+}
+var attribute = (raw, boolean) => ({
+  kind: "Attribute",
+  name: boolean ? raw.name.slice(1) : raw.name,
+  value: raw.value,
+  boolean,
+  loc: raw.loc
+});
+var CORE_DIRECTIVES = [
+  // Events: `@click=${h}`, `on:click=${h}` (native), `onClick=${h}`, each with
+  // optional dotted modifiers (`@click.capture.once`, `on:input.passive`).
+  {
+    id: "event",
+    match: (n) => n[0] === "@" || n.startsWith("on:") || /^on[A-Z]/.test(n),
+    build: (raw) => {
+      let syntax;
+      let rest;
+      if (raw.name[0] === "@") {
+        syntax = "at";
+        rest = raw.name.slice(1);
+      } else if (raw.name.startsWith("on:")) {
+        syntax = "colon";
+        rest = raw.name.slice(3);
+      } else {
+        syntax = "on";
+        rest = raw.name.slice(2);
+      }
+      const [raw_name, ...modifiers] = rest.split(".");
+      const name = raw_name.toLowerCase();
+      for (const m of modifiers) {
+        if (!EVENT_MODIFIERS.has(m)) {
+          raw.report("invalid-directive", `Unknown event modifier ".${m}" \u2014 expected one of ${[...EVENT_MODIFIERS].join(", ")}`);
+        }
+      }
+      return {
+        kind: "EventBinding",
+        name,
+        syntax,
+        modifiers,
+        hole: requireHole(raw, "event binding"),
+        loc: raw.loc
+      };
+    }
+  },
+  // Two-way binding: `bind:value=${signal}`.
+  {
+    id: "bind",
+    elementOnly: true,
+    match: (n) => n.startsWith("bind:"),
+    build: (raw) => ({
+      kind: "BindDirective",
+      name: raw.name.slice("bind:".length),
+      hole: requireHole(raw, "two-way binding"),
+      loc: raw.loc
+    })
+  },
+  // Dynamic class toggle: `class:active=${flag}`.
+  {
+    id: "class-directive",
+    elementOnly: true,
+    match: (n) => n.startsWith("class:"),
+    build: (raw) => ({
+      kind: "ClassDirective",
+      name: raw.name.slice("class:".length),
+      hole: requireHole(raw, "class directive"),
+      loc: raw.loc
+    })
+  },
+  // Dynamic style: `style:color=${c}`.
+  {
+    id: "style-directive",
+    elementOnly: true,
+    match: (n) => n.startsWith("style:"),
+    build: (raw) => ({
+      kind: "StyleDirective",
+      name: raw.name.slice("style:".length),
+      hole: requireHole(raw, "style directive"),
+      loc: raw.loc
+    })
+  },
+  // Load strategy: `load:visible[="200px"]`. Components only, an intrinsic element
+  // has no module to defer.
+  {
+    id: "load",
+    match: (n) => n.startsWith("load:"),
+    build: (raw) => ({
+      kind: "LoadDirective",
+      strategy: raw.name.slice("load:".length),
+      modifier: raw.value && raw.value.kind === "static" ? raw.value.value : null,
+      loc: raw.loc
+    })
+  },
+  // Custom directive: `use=${d}` or `use:tooltip[=${opts}]`.
+  {
+    id: "use",
+    match: (n) => n === "use" || n.startsWith("use:"),
+    build: (raw) => {
+      const named = raw.name.startsWith("use:");
+      return {
+        kind: "UseDirective",
+        name: named ? raw.name.slice("use:".length) : null,
+        hole: raw.value && raw.value.kind === "hole" ? raw.value.hole : null,
+        loc: raw.loc
+      };
+    }
+  },
+  // Conditional rendering: `if=${cond}`.
+  {
+    id: "if",
+    elementOnly: true,
+    match: (n) => n === "if",
+    build: (raw) => ({
+      kind: "IfDirective",
+      hole: requireHole(raw, "if directive"),
+      loc: raw.loc
+    })
+  },
+  // Loop rendering: `each=${items}` (a sibling `key` folds in at parse time).
+  {
+    id: "each",
+    elementOnly: true,
+    match: (n) => n === "each",
+    build: (raw) => ({
+      kind: "EachDirective",
+      hole: requireHole(raw, "each directive"),
+      key: null,
+      loc: raw.loc
+    })
+  },
+  // `else` (valueless).
+  {
+    id: "else",
+    elementOnly: true,
+    match: (n) => n === "else",
+    build: (raw) => {
+      if (raw.value !== null) raw.report("invalid-directive", "`else` takes no value");
+      return { kind: "ElseDirective", loc: raw.loc };
     }
+  },
+  // Ref binding: `ref=${el}`.
+  {
+    id: "ref",
+    match: (n) => n === "ref",
+    build: (raw) => ({
+      kind: "RefBinding",
+      hole: requireHole(raw, "ref binding"),
+      loc: raw.loc
+    })
+  },
+  // Property binding: `.currentTime=${t}`.
+  {
+    id: "property",
+    match: (n) => n[0] === ".",
+    build: (raw) => ({
+      kind: "PropertyBinding",
+      name: raw.name.slice(1),
+      hole: requireHole(raw, "property binding"),
+      loc: raw.loc
+    })
+  },
+  // Boolean attribute (lit `?disabled`): a plain attribute flagged boolean.
+  {
+    id: "boolean",
+    match: (n) => n[0] === "?",
+    build: (raw) => attribute(raw, true)
+  }
+];
+function resolveAttribute(raw, directives = CORE_DIRECTIVES, ctx = { component: false }) {
+  for (const d of directives) {
+    if (d.elementOnly && ctx.component) continue;
+    if (d.match(raw.name)) return d.build(raw);
+  }
+  return attribute(raw, false);
+}
+var SVG_TAGS = /* @__PURE__ */ new Set([
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "line",
+  "polygon",
+  "polyline",
+  "ellipse",
+  "g",
+  "defs",
+  "clipPath",
+  "text"
+]);
+var RAW_TEXT_ELEMENTS = /* @__PURE__ */ new Set(["script", "style", "textarea", "title"]);
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function isComponentTag(tag) {
+  return tag.length > 0 && (tag[0] !== tag[0].toLowerCase() || tag.includes("."));
+}
+var INTERACTIVE = /* @__PURE__ */ new Set([
+  "a",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "summary",
+  "details",
+  "option",
+  "label"
+]);
+var KEY_EVENTS = /* @__PURE__ */ new Set(["keydown", "keyup", "keypress"]);
+function attributeNamed(node, name) {
+  return node.attributes.find((a) => "name" in a && a.name === name);
+}
+function hasSpread(node) {
+  return node.attributes.some((a) => a.kind === "Spread");
+}
+function staticValue(node, name) {
+  const attribute2 = attributeNamed(node, name);
+  if (!attribute2 || attribute2.kind !== "Attribute" || !attribute2.value) return void 0;
+  const value = attribute2.value;
+  return value.kind === "static" ? value.value : void 0;
+}
+function isPresentational(node) {
+  const role = staticValue(node, "role");
+  if (role === "presentation" || role === "none") return true;
+  return staticValue(node, "aria-hidden") === "true";
+}
+function hasEvent(node, predicate) {
+  return node.attributes.some((a) => a.kind === "EventBinding" && predicate(a.name));
+}
+function checkAccessibility(root) {
+  const out = [];
+  const report = (node, code, message) => {
+    out.push({ code, message, severity: "warning", loc: node.loc });
   };
-  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) {
+  const visit = (nodes) => {
+    for (const node of nodes) {
+      if (node.kind === "Element") check(node, report);
+      const children = "children" in node ? node.children : void 0;
+      if (children) visit(children);
+    }
+  };
+  visit(root.children);
+  return out;
+}
+function check(node, report) {
+  if (hasSpread(node)) return;
+  const tag = node.tag.toLowerCase();
+  if (tag === "img" && !attributeNamed(node, "alt") && !isPresentational(node)) {
+    report(node, "a11y-img-alt", 'An `img` needs an `alt`. Use `alt=""` when the image is decorative.');
+  }
+  if (tag === "a" && !attributeNamed(node, "href") && !attributeNamed(node, "role")) {
+    report(node, "a11y-anchor-href", "An `a` without `href` is not a link. Use a `button` for an action.");
+  }
+  if (tag === "iframe" && !attributeNamed(node, "title")) {
+    report(node, "a11y-iframe-title", "An `iframe` needs a `title` describing its content.");
+  }
+  const tabindex = staticValue(node, "tabindex") ?? staticValue(node, "tabIndex");
+  if (tabindex !== void 0 && Number(tabindex) > 0) {
+    report(
+      node,
+      "a11y-positive-tabindex",
+      "A positive `tabindex` reorders tab navigation for the entire page. Use `0`, or restructure the markup."
+    );
+  }
+  if (!INTERACTIVE.has(tag) && hasEvent(node, (name) => name === "click") && !attributeNamed(node, "role") && !hasEvent(node, (name) => KEY_EVENTS.has(name))) {
+    report(
+      node,
+      "a11y-click-without-keyboard",
+      `A click handler on \`${tag}\` is unreachable by keyboard. Use a \`button\`, or add a \`role\` and a key handler.`
+    );
+  }
+}
+var NAME_CHAR = /[A-Za-z0-9\-_:@.?]/;
+var Parser = class {
+  constructor(pieces, opts) {
     this.diagnostics = [];
-    this.r = new m(t), this.svg = i2.svg ?? false, this.directives = i2.directives ?? f, this.accessibility = i2.accessibility ?? true;
+    this.r = new Reader(pieces);
+    this.svg = opts.svg ?? false;
+    this.directives = opts.directives ?? CORE_DIRECTIVES;
+    this.accessibility = opts.accessibility ?? true;
   }
   parse() {
-    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));
+    const start = this.r.pos();
+    const children = [];
+    while (!this.r.eof()) {
+      children.push(...this.parseChildren());
+      if (this.r.eof()) break;
+      const s = this.r.pos();
+      this.consumeCloseTag();
+      this.report("stray-close-tag", "error", "Close tag without a matching open tag", this.r.span(s));
     }
-    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 };
+    const root = { kind: "Root", children, loc: this.r.span(start) };
+    setParents(root);
+    this.validateTree(root);
+    if (this.accessibility) {
+      this.diagnostics.push(...checkAccessibility(root));
+    }
+    return { root, diagnostics: this.diagnostics };
   }
-  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));
+  /** Cross-node validation that needs the built tree (sibling relationships). */
+  validateTree(root) {
+    const visit = (nodes) => {
+      let prevBranch = null;
+      for (const node of nodes) {
+        if (node.kind === "Text" && /^\s*$/.test(node.value)) continue;
+        if (node.kind === "Element" || node.kind === "Component") {
+          const hasElse = node.attributes.some((a) => a.kind === "ElseDirective");
+          if (hasElse) {
+            const prevHasIf = prevBranch != null && (prevBranch.kind === "Element" || prevBranch.kind === "Component") && prevBranch.attributes.some((a) => a.kind === "IfDirective");
+            if (!prevHasIf) {
+              this.report("else-without-if", "error", "`else` must immediately follow an element with `if`", node.loc);
+            }
+          }
+          prevBranch = node;
+        } else {
+          prevBranch = null;
+        }
+        if ("children" in node && node.children) visit(node.children);
+      }
     };
-    i2(t.children);
+    visit(root.children);
   }
+  // --- content ------------------------------------------------------------
+  /** Parse sibling nodes until EOF or a `</` close the caller must consume. */
   parseChildren() {
-    let t = [];
-    for (; !this.r.eof() && !this.r.startsWith("</"); ) {
+    const out = [];
+    while (!this.r.eof()) {
+      if (this.r.startsWith("</")) break;
       if (this.r.startsWith("<!--")) {
-        t.push(this.parseComment());
+        out.push(this.parseComment());
         continue;
       }
       if (this.isFragmentStart()) {
-        t.push(this.parseFragment());
+        out.push(this.parseFragment());
         continue;
       }
       if (this.isDynamicTagStart()) {
-        t.push(this.parseDynamicComponent());
+        out.push(this.parseDynamicComponent());
         continue;
       }
       if (this.isTagStart()) {
-        t.push(this.parseElement());
+        out.push(this.parseElement());
         continue;
       }
       if (this.r.atHole()) {
-        let n = this.r.takeHole(), r = { kind: "Expression", hole: n.index, loc: n.loc };
-        t.push(r);
+        const h = this.r.takeHole();
+        const node = { kind: "Expression", hole: h.index, loc: h.loc };
+        out.push(node);
         continue;
       }
-      let i2 = this.readText();
-      i2 && t.push(i2);
+      const text = this.readText();
+      if (text) out.push(text);
     }
-    return t;
+    return out;
   }
   isTagStart() {
     return this.r.peek() === "<" && /[A-Za-z]/.test(this.r.peek(1));
@@ -215,166 +494,306 @@ var N = class {
   isFragmentStart() {
     return this.r.peek() === "<" && this.r.peek(1) === ">";
   }
+  /** `<${Comp} …>`: a component whose tag is an interpolated expression. */
   isDynamicTagStart() {
     return this.r.peek() === "<" && this.r.holeFollows();
   }
+  /** Parse `<${Comp} …/>` or `<${Comp} …>…</${Comp}>` into a dynamic ComponentNode. */
   parseDynamicComponent() {
-    let t = this.r.pos();
+    const start = this.r.pos();
     this.r.advance();
-    let i2 = this.r.takeHole().index, n = this.parseAttributes(true);
+    const tagHole = this.r.takeHole().index;
+    const attributes = this.parseAttributes(true);
     this.r.skipWhitespace();
-    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) };
+    let selfClosing = false;
+    let children = [];
+    if (this.r.startsWith("/>")) {
+      this.r.advance();
+      this.r.advance();
+      selfClosing = true;
+    } else {
+      if (this.r.peek() === ">") this.r.advance();
+      children = this.parseChildren();
+      if (this.r.startsWith("</")) {
+        this.r.advance();
+        this.r.advance();
+        if (this.r.atHole()) this.r.takeHole();
+        else this.readName();
+        this.r.skipWhitespace();
+        if (this.r.peek() === ">") this.r.advance();
+      } else {
+        this.report("unclosed-tag", "error", "Unclosed dynamic component", this.r.span(start));
+      }
+    }
+    return { kind: "Component", tag: "", tagHole, attributes, children, selfClosing, loc: this.r.span(start) };
   }
+  /** A raw text run (preserved verbatim; whitespace is normalized at lowering). */
   readText() {
-    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;
+    const start = this.r.pos();
+    let value = "";
+    while (!this.r.eof() && !this.r.atHole()) {
+      if (this.r.startsWith("</") || this.r.startsWith("<!--") || this.isTagStart() || this.isFragmentStart() || this.isDynamicTagStart()) break;
+      value += this.r.advance();
+    }
+    if (!value) return null;
+    return { kind: "Text", value, raw: false, loc: this.r.span(start) };
   }
   parseComment() {
-    let t = this.r.pos();
-    this.r.advance(), this.r.advance(), this.r.advance(), this.r.advance();
-    let i2 = "";
-    for (; !this.r.eof() && !this.r.startsWith("-->"); ) {
+    const start = this.r.pos();
+    this.r.advance();
+    this.r.advance();
+    this.r.advance();
+    this.r.advance();
+    let value = "";
+    while (!this.r.eof() && !this.r.startsWith("-->")) {
       if (this.r.atHole()) {
-        this.r.takeHole(), i2 += "\0";
+        this.r.takeHole();
+        value += "\0";
         continue;
       }
-      i2 += this.r.advance();
+      value += 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(t)), { kind: "Comment", value: i2, loc: this.r.span(t) };
+    if (this.r.startsWith("-->")) {
+      this.r.advance();
+      this.r.advance();
+      this.r.advance();
+    } else {
+      this.report("unclosed-comment", "warning", "Unterminated comment", this.r.span(start));
+    }
+    return { kind: "Comment", value, loc: this.r.span(start) };
   }
   parseFragment() {
-    let t = this.r.pos();
-    this.r.advance(), this.r.advance();
-    let i2 = this.parseChildren();
+    const start = this.r.pos();
+    this.r.advance();
+    this.r.advance();
+    const children = this.parseChildren();
     if (this.r.startsWith("</")) {
-      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) };
+      const name = this.consumeCloseTag();
+      if (name) this.report("mismatched-close-tag", "error", `Expected </> to close fragment, got </${name}>`, this.r.span(start));
+    } else {
+      this.report("unclosed-tag", "error", "Unterminated fragment", this.r.span(start));
+    }
+    return { kind: "Fragment", children, loc: this.r.span(start) };
   }
   parseElement() {
-    let t = this.r.pos();
+    const start = this.r.pos();
     this.r.advance();
-    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 = "";
+    const tag = this.readName();
+    const component = isComponentTag(tag);
+    const attributes = this.parseAttributes(component);
+    this.foldEachKey(attributes, start);
+    this.r.skipWhitespace();
+    const lower = tag.toLowerCase();
+    const rawText = !component && RAW_TEXT_ELEMENTS.has(lower);
+    const isVoid = !component && VOID_ELEMENTS.has(lower);
+    let selfClosing = false;
+    let children = [];
+    if (this.r.startsWith("/>")) {
+      this.r.advance();
+      this.r.advance();
+      selfClosing = true;
+    } else {
+      if (this.r.peek() === ">") this.r.advance();
+      if (!isVoid) {
+        children = rawText ? this.parseRawText(tag) : this.parseChildren();
+        if (this.r.startsWith("</")) {
+          const name = this.consumeCloseTag();
+          if (name && name !== tag) {
+            this.report("mismatched-close-tag", "error", `Expected </${tag}>, got </${name}>`, this.r.span(start));
+          }
+        } else {
+          this.report("unclosed-tag", "error", `Unclosed <${tag}>`, this.r.span(start));
+        }
+      }
+    }
+    const loc = this.r.span(start);
+    if (component) {
+      return { kind: "Component", tag, tagHole: null, attributes, children, selfClosing, loc };
+    }
+    const namespace = this.svg || SVG_TAGS.has(tag) ? "svg" : "html";
+    return { kind: "Element", tag, namespace, attributes, children, selfClosing, rawText, loc };
+  }
+  /** Read a raw-text element body: only holes break the text run. */
+  parseRawText(tag) {
+    const out = [];
+    const close = "</" + tag.toLowerCase();
+    let text = "";
+    let start = this.r.pos();
+    const flush = () => {
+      if (text) out.push({ kind: "Text", value: text, raw: true, loc: this.r.span(start) });
+      text = "";
     };
-    for (; !this.r.eof() && !this.startsWithCloseFor(n); ) {
+    while (!this.r.eof()) {
+      if (this.startsWithCloseFor(close)) break;
       if (this.r.atHole()) {
-        o();
-        let l2 = this.r.takeHole();
-        i2.push({ kind: "Expression", hole: l2.index, loc: l2.loc }), s2 = this.r.pos();
+        flush();
+        const h = this.r.takeHole();
+        out.push({ kind: "Expression", hole: h.index, loc: h.loc });
+        start = this.r.pos();
         continue;
       }
-      r || (s2 = this.r.pos()), r += this.r.advance();
+      if (!text) start = this.r.pos();
+      text += this.r.advance();
     }
-    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++;
+    flush();
+    return out;
+  }
+  startsWithCloseFor(close) {
+    let i = 0;
+    while (i < close.length) {
+      const ch = this.r.peek(i);
+      if (ch === "" || ch.toLowerCase() !== close[i]) return false;
+      i++;
     }
     return true;
   }
-  parseAttributes(t) {
-    let i2 = [];
-    for (; !this.r.eof() && (this.r.skipWhitespace(), !(this.r.peek() === ">" || this.r.startsWith("/>"))); ) {
+  // --- attributes ---------------------------------------------------------
+  parseAttributes(component) {
+    const props = [];
+    while (!this.r.eof()) {
+      this.r.skipWhitespace();
+      if (this.r.peek() === ">" || this.r.startsWith("/>")) break;
       if (this.r.atHole()) {
-        let a2 = this.r.takeHole();
-        i2.push({ kind: "Spread", hole: a2.index, loc: a2.loc });
+        const h = this.r.takeHole();
+        props.push({ kind: "Spread", hole: h.index, loc: h.loc });
         continue;
       }
       if (this.r.startsWith("...")) {
-        let a2 = this.r.pos();
-        if (this.r.advance(), this.r.advance(), this.r.advance(), this.r.atHole()) {
-          let c = this.r.takeHole();
-          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));
+        const s = this.r.pos();
+        this.r.advance();
+        this.r.advance();
+        this.r.advance();
+        if (this.r.atHole()) {
+          const h = this.r.takeHole();
+          props.push({ kind: "Spread", hole: h.index, loc: this.r.span(s) });
+        } else {
+          this.report("invalid-binding", "error", "Spread `...` must be followed by ${\u2026}", this.r.span(s));
+        }
         continue;
       }
-      let n = this.r.pos(), r = this.readName();
-      if (!r) {
+      const nameStart = this.r.pos();
+      const name = this.readName();
+      if (!name) {
         this.r.advance();
         continue;
       }
-      let s2 = this.r.span(n);
+      const nameLoc = this.r.span(nameStart);
       this.r.skipWhitespace();
-      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 }));
+      let value = null;
+      if (this.r.peek() === "=") {
+        this.r.advance();
+        this.r.skipWhitespace();
+        value = this.parseAttrValue();
+      }
+      const raw = {
+        name,
+        nameLoc,
+        value,
+        loc: this.r.span(nameStart),
+        report: (code, message) => this.report(code, "error", message, this.r.span(nameStart))
+      };
+      props.push(resolveAttribute(raw, this.directives, { component }));
     }
-    return i2;
+    return props;
   }
   parseAttrValue() {
-    if (this.r.atHole()) return { kind: "hole", hole: this.r.takeHole().index };
-    let t = this.r.peek();
-    return t === '"' || t === "'" ? this.classifyParts(this.readQuotedParts(t)) : { kind: "static", value: this.r.readWhile((n) => !/[\s>]/.test(n)) };
+    if (this.r.atHole()) {
+      const h = this.r.takeHole();
+      return { kind: "hole", hole: h.index };
+    }
+    const quote = this.r.peek();
+    if (quote === '"' || quote === "'") {
+      return this.classifyParts(this.readQuotedParts(quote));
+    }
+    const value = this.r.readWhile((ch) => !/[\s>]/.test(ch));
+    return { kind: "static", value };
   }
-  readQuotedParts(t) {
+  readQuotedParts(quote) {
     this.r.advance();
-    let i2 = [], n = "";
-    for (; !this.r.eof() && this.r.peek() !== t; ) {
+    const parts = [];
+    let text = "";
+    while (!this.r.eof() && this.r.peek() !== quote) {
       if (this.r.atHole()) {
-        n && (i2.push({ text: n }), n = ""), i2.push({ hole: this.r.takeHole().index });
+        if (text) {
+          parts.push({ text });
+          text = "";
+        }
+        parts.push({ hole: this.r.takeHole().index });
         continue;
       }
-      let r = this.r.advance();
-      if (r === "") break;
-      n += r;
+      const ch = this.r.advance();
+      if (ch === "") break;
+      text += ch;
     }
-    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);
+    if (text) parts.push({ text });
+    if (this.r.peek() === quote) this.r.advance();
+    return parts;
+  }
+  classifyParts(parts) {
+    const holes = parts.filter((p) => "hole" in p);
+    if (holes.length === 0) {
+      return { kind: "static", value: parts.map((p) => "text" in p ? p.text : "").join("") };
+    }
+    if (parts.length === 1) return { kind: "hole", hole: holes[0].hole };
+    return { kind: "mixed", parts };
+  }
+  /** Fold `key` into `each`, and validate an element's directive combination. */
+  foldEachKey(attrs, elLoc) {
+    let each = null;
+    let ifCount = 0;
+    let eachCount = 0;
+    let elseCount = 0;
+    let refCount = 0;
+    for (const a of attrs) {
+      if (a.kind === "EachDirective") {
+        each = a;
+        eachCount++;
+      } else if (a.kind === "IfDirective") ifCount++;
+      else if (a.kind === "ElseDirective") elseCount++;
+      else if (a.kind === "RefBinding") refCount++;
+    }
+    const span = this.r.span(elLoc);
+    if (eachCount > 1) this.report("duplicate-directive", "error", "Multiple `each` directives on one element", span);
+    if (ifCount > 1) this.report("duplicate-directive", "error", "Multiple `if` directives on one element", span);
+    if (refCount > 1) this.report("duplicate-directive", "error", "Multiple `ref` bindings on one element", span);
+    if (ifCount > 0 && eachCount > 0) {
+      this.report("unsupported-combination", "error", "`if` and `each` cannot both apply to one element \u2014 wrap one in another element", span);
+    }
+    if (ifCount > 0 && elseCount > 0) {
+      this.report("invalid-directive", "error", "`if` and `else` cannot be on the same element", span);
+    }
+    const keyIdx = attrs.findIndex((a) => a.kind === "Attribute" && a.name === "key");
+    if (!each) {
+      if (keyIdx !== -1) this.report("invalid-directive", "error", "`key` requires an `each` directive on the same element", span);
       return;
     }
-    if (c === -1) return;
-    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);
+    if (keyIdx === -1) return;
+    const key = attrs[keyIdx];
+    if (key.kind === "Attribute" && key.value) {
+      if (key.value.kind === "static") each.key = { static: key.value.value };
+      else if (key.value.kind === "hole") each.key = { hole: key.value.hole };
+    }
+    attrs.splice(keyIdx, 1);
   }
+  // --- low level ----------------------------------------------------------
   readName() {
-    return this.r.readWhile((t) => V.test(t));
+    return this.r.readWhile((ch) => NAME_CHAR.test(ch));
   }
+  /** Consume `</name>` (or `</>`), returning the close-tag name (may be ''). */
   consumeCloseTag() {
-    this.r.advance(), this.r.advance();
-    let t = this.readName();
-    return this.r.skipWhitespace(), this.r.peek() === ">" && this.r.advance(), t;
+    this.r.advance();
+    this.r.advance();
+    const name = this.readName();
+    this.r.skipWhitespace();
+    if (this.r.peek() === ">") this.r.advance();
+    return name;
   }
-  report(t, i2, n, r) {
-    this.diagnostics.push({ code: t, severity: i2, message: n, loc: r });
+  report(code, severity, message, loc) {
+    this.diagnostics.push({ code, severity, message, loc });
   }
 };
-function b(e, t = {}) {
-  return new N(e, t).parse();
+function parseTemplate(pieces, opts = {}) {
+  return new Parser(pieces, opts).parse();
 }
 
 // src/pieces.ts
@@ -390,9 +809,9 @@ function templatePieces(ts, tpl, sf) {
   const pieces = [
     { kind: "static", text: rawContent(ts, tpl.head, sf), start: tpl.head.getStart(sf) + 1 }
   ];
-  tpl.templateSpans.forEach((span, i2) => {
+  tpl.templateSpans.forEach((span, i) => {
     const e = span.expression;
-    pieces.push({ kind: "hole", index: i2, start: e.getStart(sf), end: e.getEnd() });
+    pieces.push({ kind: "hole", index: i, start: e.getStart(sf), end: e.getEnd() });
     pieces.push({
       kind: "static",
       text: rawContent(ts, span.literal, sf),
@@ -413,7 +832,7 @@ function parseCached(ts, sf, tpl) {
   const key = tpl.getStart(sf);
   const hit = byTemplate.get(key);
   if (hit) return hit;
-  const result = b(templatePieces(ts, tpl, sf));
+  const result = parseTemplate(templatePieces(ts, tpl, sf));
   byTemplate.set(key, result);
   return result;
 }
@@ -437,7 +856,7 @@ function templatesIn(ts, sf) {
     ts.forEachChild(node, visit);
   };
   visit(sf);
-  found.sort((a2, b2) => a2.getStart(sf) - b2.getStart(sf));
+  found.sort((a, b) => a.getStart(sf) - b.getStart(sf));
   templates.set(sf, found);
   return found;
 }
@@ -510,21 +929,42 @@ function importedNames(ts, decl) {
 }
 
 // ../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" } = 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;
+var DOM_CONTROL_FLOW = [
+  "Show",
+  "For",
+  "Index",
+  "Switch",
+  "Match",
+  "Portal",
+  "Dynamic",
+  "ErrorBoundary"
+];
+var CORE_CONTROL_FLOW = ["Suspense", "SuspenseList", "Await"];
+var ROUTER_COMPONENTS = ["Router", "Outlet", "Redirect", "Link"];
+var BUILTIN_COMPONENTS = [
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW,
+  ...ROUTER_COMPONENTS
+];
+var RESERVED_COMPONENTS = /* @__PURE__ */ new Set([
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW
+]);
+function builtinComponentMap(modules = {}) {
+  const {
+    controlFlowModule = "@fluixi/dom",
+    coreModule = "@fluixi/core",
+    routerModule = "@fluixi/core/router"
+  } = modules;
+  const map = {};
+  for (const name of DOM_CONTROL_FLOW) map[name] = controlFlowModule;
+  for (const name of CORE_CONTROL_FLOW) map[name] = coreModule;
+  for (const name of ROUTER_COMPONENTS) map[name] = routerModule;
+  return map;
 }
 
 // src/auto-import.ts
-var AUTO_IMPORTED = l();
+var AUTO_IMPORTED = builtinComponentMap();
 var exportsByProgram = /* @__PURE__ */ new WeakMap();
 function moduleExports(ts, program, host, from, moduleName) {
   let cache2 = exportsByProgram.get(program);
@@ -597,7 +1037,7 @@ function findExport(ts, host, options, fileName, name, depth) {
   return void 0;
 }
 function declaredName(ts, statement, name) {
-  const exported = ts.canHaveModifiers(statement) ? ts.getModifiers(statement)?.some((m2) => m2.kind === ts.SyntaxKind.ExportKeyword) : false;
+  const exported = ts.canHaveModifiers(statement) ? ts.getModifiers(statement)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) : false;
   if (!exported) return void 0;
   if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name?.text === name) {
     return statement.name;
@@ -620,7 +1060,7 @@ function resolveRelative(ts, host, options, from, specifier) {
 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);
+  const symbol = moduleExports(ts, program, host, from, moduleName)?.find((s) => s.name === name);
   if (!symbol) return void 0;
   if (!(symbol.flags & ts.SymbolFlags.Alias)) return symbol;
   try {
@@ -641,7 +1081,7 @@ function componentQuickInfo(ts, ls, host, fileName, position) {
   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((s2) => s2.name === hit.name) ?? autoImportedSymbol(ts, program, host, sf, hit.name);
+  const symbol = checker.getSymbolsInScope(template, flags).find((s) => s.name === hit.name) ?? autoImportedSymbol(ts, program, host, sf, hit.name);
   const decl = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
   if (!decl) return void 0;
   const declFile = decl.getSourceFile();
@@ -778,21 +1218,21 @@ function holeRoles(nodes, out) {
   };
   for (const node of nodes) {
     if (node.kind === "Element" || node.kind === "Component") {
-      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 });
+      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 });
       }
-      const eachDir = node.attributes.find((a2) => a2.kind === "EachDirective");
+      const eachDir = node.attributes.find((a) => a.kind === "EachDirective");
       if (eachDir && eachDir.kind === "EachDirective") {
         renderChildren(node, { kind: "each", eachHole: eachDir.hole });
       }
       if (node.kind === "Component") {
         const propHole = (name) => {
-          const a2 = node.attributes.find(
-            (x2) => x2.kind === "Attribute" && x2.name === name && x2.value != null && x2.value.kind === "hole"
+          const a = node.attributes.find(
+            (x) => x.kind === "Attribute" && x.name === name && x.value != null && x.value.kind === "hole"
           );
-          return a2 && a2.kind === "Attribute" && a2.value && a2.value.kind === "hole" ? a2.value.hole : void 0;
+          return a && a.kind === "Attribute" && a.value && a.value.kind === "hole" ? a.value.hole : void 0;
         };
         const eachHole = propHole("each");
         if (node.tag === "For" && eachHole !== void 0) renderChildren(node, { kind: "each", eachHole });
@@ -805,7 +1245,7 @@ function holeRoles(nodes, out) {
   }
 }
 function resolveGlobalType(ts, checker, location, name) {
-  const sym = checker.getSymbolsInScope(location, ts.SymbolFlags.Type).find((s2) => s2.getName() === name);
+  const sym = checker.getSymbolsInScope(location, ts.SymbolFlags.Type).find((s) => s.getName() === name);
   return sym ? checker.getDeclaredTypeOfSymbol(sym) : void 0;
 }
 function resolveElementType(ts, checker, location, tag) {
@@ -818,7 +1258,7 @@ function inferParamAt(ts, program, 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((s2) => s2.expression);
+  const holeExprs = spans.map((s) => s.expression);
   const holeIndex = holeExprs.findIndex((e) => position >= e.getStart(sf) && position <= e.getEnd());
   if (holeIndex === -1) return void 0;
   const roles = /* @__PURE__ */ new Map();
@@ -867,7 +1307,7 @@ function inferParamsIn(ts, program, sf) {
   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 holeExprs = tpl.templateSpans.map((s) => s.expression);
     const roles = /* @__PURE__ */ new Map();
     holeRoles(parseCached(ts, sf, tpl).root.children, roles);
     for (const [holeIndex, role] of roles) {
@@ -942,8 +1382,8 @@ function componentPropCompletions(ts, ls, host, fileName, position) {
   if (!propsType) return void 0;
   const already = new Set(comp.attributeNames);
   const entries = [];
-  for (const p3 of propsType.getProperties()) {
-    const name = p3.getName();
+  for (const p of propsType.getProperties()) {
+    const name = p.getName();
     if (name === "children" || already.has(name)) continue;
     entries.push(propEntry(ts, name, span));
   }
@@ -997,10 +1437,10 @@ function propNameAt(ts, sf, tpl, position) {
     for (const node of nodes) {
       if (node.kind === "Component") {
         const c = node;
-        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 };
+        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 };
           }
         }
       }
@@ -1045,7 +1485,7 @@ function propEntry(ts, name, replacementSpan) {
     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
+    // 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
@@ -1061,7 +1501,7 @@ function attrNameSpan(text, position) {
 }
 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);
+  const symbol = checker.getSymbolsInScope(template, flags).find((s) => s.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];
@@ -1069,8 +1509,8 @@ function componentTypeOf(ts, program, checker, host, sf, template, name) {
 }
 function firstParamType(ts, checker, type) {
   for (const sig of checker.getSignaturesOfType(type, ts.SignatureKind.Call)) {
-    const p3 = sig.getParameters()[0];
-    if (p3) return checker.getTypeOfSymbolAtLocation(p3, p3.valueDeclaration ?? sig.getDeclaration());
+    const p = sig.getParameters()[0];
+    if (p) return checker.getTypeOfSymbolAtLocation(p, p.valueDeclaration ?? sig.getDeclaration());
   }
   return void 0;
 }
@@ -1101,8 +1541,8 @@ function firstChildOrCloseStart(c) {
 }
 function attributeNames(c) {
   const out = [];
-  for (const a2 of c.attributes) {
-    if (a2.kind === "Attribute" || a2.kind === "PropertyBinding" || a2.kind === "BindDirective") out.push(a2.name);
+  for (const a of c.attributes) {
+    if (a.kind === "Attribute" || a.kind === "PropertyBinding" || a.kind === "BindDirective") out.push(a.name);
   }
   return out;
 }
@@ -1119,13 +1559,13 @@ function paramMemberCompletions(ts, ls, fileName, position) {
   const checker = program.getTypeChecker();
   const already = /* @__PURE__ */ new Set();
   const entries = [];
-  for (const p3 of checker.getApparentType(info.type).getProperties()) {
-    const name = p3.getName();
+  for (const p of checker.getApparentType(info.type).getProperties()) {
+    const name = p.getName();
     if (already.has(name) || name.startsWith("__")) continue;
     already.add(name);
     entries.push({
       name,
-      kind: memberKind(ts, p3),
+      kind: memberKind(ts, p),
       kindModifiers: "",
       sortText: "0_" + name,
       insertText: name
@@ -1213,8 +1653,8 @@ function elementAtAttributeArea(ts, sf, tpl, position) {
         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));
+          for (const a of el.attributes) {
+            if ("loc" in a && a.loc) present.add(writtenName(sf.text, a.loc.start));
           }
           hit = { tag: el.tag, present };
         }
@@ -1233,8 +1673,8 @@ function writtenName(text, start) {
 }
 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);
+  for (const a of el.attributes) {
+    if ("loc" in a && a.loc) end = Math.max(end, a.loc.end);
   }
   return end + 1;
 }
@@ -1249,8 +1689,8 @@ function elementAttributeCompletions(ts, ls, host, fileName, position) {
   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();
+  for (const p of props) {
+    const name = p.getName();
     if (name === "children" || hit.present.has(name)) continue;
     entries.push({
       name,
@@ -1268,9 +1708,9 @@ function attributeNameAt(ts, sf, tpl, position) {
     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;
+        for (const a of el.attributes) {
+          if (!("loc" in a) || !a.loc) continue;
+          const start = a.loc.start;
           const name = writtenName(sf.text, start);
           if (name && position >= start && position <= start + name.length) {
             hit = { tag: el.tag, name, start };
@@ -1293,7 +1733,7 @@ function elementAttributeHover(ts, ls, host, fileName, position) {
   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);
+  const symbol = props?.find((p) => p.getName() === hit.name);
   if (!symbol) return void 0;
   const decl = symbol.valueDeclaration ?? symbol.declarations?.[0];
   if (!decl) return void 0;
@@ -1333,7 +1773,7 @@ function accessorDiagnostics(ts, program, sf) {
   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 holes = tpl.templateSpans.map((s) => s.expression);
     const visit = (nodes, parent) => {
       for (const node of nodes) {
         if (node.kind === "Expression" && parent?.kind === "Element") {
@@ -1366,7 +1806,7 @@ 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;
+  if (signature.getParameters().some((p) => !isOptional(ts, p))) return false;
   const returned = signature.getReturnType();
   return !(returned.flags & (ts.TypeFlags.Void | ts.TypeFlags.Never));
 }
@@ -1443,7 +1883,7 @@ function templateFixAll(ts, ls, fileName, errorCodes) {
     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);
+  textChanges.sort((a, b) => b.span.start - a.span.start);
   return { changes: [{ fileName, textChanges }], commands: void 0 };
 }
 
@@ -1482,12 +1922,12 @@ function closingTagName(text, end, tag) {
 }
 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);
+  return tagSpans(ts, sf).find((s) => position >= s.start && position <= s.start + s.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);
+  const symbol = checker.getSymbolsInScope(location, flags).find((s) => s.name === name);
   if (!symbol) return autoImportedSymbol(ts, program, host, location.getSourceFile(), name);
   return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
 }
@@ -1577,8 +2017,8 @@ function templateReferences(ts, ls, host, fileName, position) {
   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,
+  return tagOccurrences(ts, program, host, hit.symbol, hit.name).map(({ fileName: f, span }) => ({
+    fileName: f,
     textSpan: span,
     isWriteAccess: false,
     isDefinition: false
@@ -1590,8 +2030,8 @@ function templateRenameLocations(ts, ls, host, fileName, position) {
   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,
+  return tagOccurrences(ts, program, host, hit.symbol, hit.name).map(({ fileName: f, span }) => ({
+    fileName: f,
     textSpan: span
   }));
 }
@@ -1613,8 +2053,8 @@ function init(modules) {
         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.
+        // 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,
@@ -1623,8 +2063,8 @@ function init(modules) {
       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}`;
+        return items.filter((i) => {
+          const key = `${i.fileName}:${i.textSpan.start}:${i.textSpan.length}`;
           if (seen.has(key)) return false;
           seen.add(key);
           return true;
@@ -1761,3 +2201,5 @@ function init(modules) {
   };
 }
 module.exports = init;
+/*! @fluixi/template-parser v0.1.0-alpha.4 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+/*! @fluixi/compiler v1.0.0-alpha.85 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */