@fluixi/ts-plugin 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1373 @@
+"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);
+  };
+  return e(t, null), t;
+}
+function C(t) {
+  switch (t.kind) {
+    case "Root":
+    case "Element":
+    case "Component":
+    case "Fragment":
+      return t.children;
+    default:
+      return [];
+  }
+}
+var u = class {
+  constructor(e) {
+    this.pieces = e;
+    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) {
+        this.pi++, this.oi = 0;
+        continue;
+      }
+      break;
+    }
+  }
+  eof() {
+    return this.pi >= this.pieces.length;
+  }
+  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 e = this.pieces[this.pi];
+    return e.kind === "static" ? e.start + this.oi : e.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";
+  }
+  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 } };
+  }
+  peek(e = 0) {
+    if (this.eof()) return "";
+    let i = this.pieces[this.pi];
+    return i.kind !== "static" ? "" : i.text[this.oi + e] ?? "";
+  }
+  startsWith(e) {
+    if (this.eof()) return false;
+    let i = this.pieces[this.pi];
+    return i.kind !== "static" ? false : i.text.startsWith(e, 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;
+  }
+  readWhile(e) {
+    let i = "";
+    for (; !this.eof() && !this.atHole(); ) {
+      let r = this.peek();
+      if (r === "" || !e(r)) break;
+      i += r, this.oi++;
+    }
+    return this.normalize(), i;
+  }
+  skipWhitespace() {
+    this.readWhile((e) => /\s/.test(e));
+  }
+  span(e) {
+    return { start: e, 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) {
+    this.diagnostics = [];
+    this.r = new u(e), this.svg = i.svg ?? false, this.directives = i.directives ?? m;
+  }
+  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 r = { kind: "Root", children: i, loc: this.r.span(e) };
+    return N(r), this.validateTree(r), { root: r, 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));
+    };
+    i(e.children);
+  }
+  parseChildren() {
+    let e = [];
+    for (; !this.r.eof() && !this.r.startsWith("</"); ) {
+      if (this.r.startsWith("<!--")) {
+        e.push(this.parseComment());
+        continue;
+      }
+      if (this.isFragmentStart()) {
+        e.push(this.parseFragment());
+        continue;
+      }
+      if (this.isDynamicTagStart()) {
+        e.push(this.parseDynamicComponent());
+        continue;
+      }
+      if (this.isTagStart()) {
+        e.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);
+        continue;
+      }
+      let i = this.readText();
+      i && e.push(i);
+    }
+    return e;
+  }
+  isTagStart() {
+    return this.r.peek() === "<" && /[A-Za-z]/.test(this.r.peek(1));
+  }
+  isFragmentStart() {
+    return this.r.peek() === "<" && this.r.peek(1) === ">";
+  }
+  isDynamicTagStart() {
+    return this.r.peek() === "<" && this.r.holeFollows();
+  }
+  parseDynamicComponent() {
+    let e = this.r.pos();
+    this.r.advance();
+    let i = this.r.takeHole().index, r = 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) };
+  }
+  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;
+  }
+  parseComment() {
+    let e = this.r.pos();
+    this.r.advance(), this.r.advance(), this.r.advance(), this.r.advance();
+    let i = "";
+    for (; !this.r.eof() && !this.r.startsWith("-->"); ) {
+      if (this.r.atHole()) {
+        this.r.takeHole(), i += "\0";
+        continue;
+      }
+      i += 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) };
+  }
+  parseFragment() {
+    let e = this.r.pos();
+    this.r.advance(), this.r.advance();
+    let i = 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) };
+  }
+  parseElement() {
+    let e = 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 = "";
+    };
+    for (; !this.r.eof() && !this.startsWithCloseFor(r); ) {
+      if (this.r.atHole()) {
+        a();
+        let l = this.r.takeHole();
+        i.push({ kind: "Expression", hole: l.index, loc: l.loc }), s = this.r.pos();
+        continue;
+      }
+      n || (s = this.r.pos()), n += 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 true;
+  }
+  parseAttributes(e) {
+    let i = [];
+    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 });
+        continue;
+      }
+      if (this.r.startsWith("...")) {
+        let o = 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));
+        continue;
+      }
+      let r = this.r.pos(), n = this.readName();
+      if (!n) {
+        this.r.advance();
+        continue;
+      }
+      let s = this.r.span(r);
+      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 }));
+    }
+    return i;
+  }
+  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)) };
+  }
+  readQuotedParts(e) {
+    this.r.advance();
+    let i = [], r = "";
+    for (; !this.r.eof() && this.r.peek() !== e; ) {
+      if (this.r.atHole()) {
+        r && (i.push({ text: r }), r = ""), i.push({ hole: this.r.takeHole().index });
+        continue;
+      }
+      let n = this.r.advance();
+      if (n === "") break;
+      r += n;
+    }
+    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;
+    }
+    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);
+  }
+  readName() {
+    return this.r.readWhile((e) => T.test(e));
+  }
+  consumeCloseTag() {
+    this.r.advance(), this.r.advance();
+    let e = this.readName();
+    return this.r.skipWhitespace(), this.r.peek() === ">" && this.r.advance(), e;
+  }
+  report(e, i, r, n) {
+    this.diagnostics.push({ code: e, severity: i, message: r, loc: n });
+  }
+};
+function k(t, e = {}) {
+  return new g(t, e).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 F(t, e = {}) {
+  return k(A(t), e);
+}
+
+// src/collect.ts
+var UNUSED_CODES = /* @__PURE__ */ new Set([6133, 6196, 6198, 6199, 6205, 6138, 6192]);
+function isUnusedCode(code) {
+  return UNUSED_CODES.has(code);
+}
+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);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return tags;
+}
+function templateStatics(ts, tpl) {
+  if (ts.isNoSubstitutionTemplateLiteral(tpl)) return [tpl.text];
+  const out = [tpl.head.text];
+  for (const span of tpl.templateSpans) out.push(span.literal.text);
+  return out;
+}
+function collectTags(nodes, out) {
+  for (const node of nodes) {
+    if (node.kind === "Component" && node.tag) out.add(node.tag.split(".")[0]);
+    if ("children" in node && node.children) collectTags(node.children, out);
+  }
+}
+function shouldSuppress(ts, sourceFile, diagnostic, used) {
+  if (diagnostic.start === void 0 || !isUnusedCode(diagnostic.code)) return false;
+  const spanText = sourceFile.text.substr(diagnostic.start, diagnostic.length ?? 0);
+  const decl = importDeclarationAt(ts, sourceFile, diagnostic.start);
+  if (decl) {
+    const names = importedNames(ts, decl);
+    if (names.includes(spanText)) return used.has(spanText);
+    return names.some((n) => used.has(n));
+  }
+  return used.has(spanText);
+}
+function importDeclarationAt(ts, sourceFile, pos) {
+  let found;
+  const visit = (node) => {
+    if (found) return;
+    if (ts.isImportDeclaration(node) && node.getStart(sourceFile) <= pos && node.getEnd() >= pos) {
+      found = node;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}
+function importedNames(ts, decl) {
+  const bindings = decl.importClause?.namedBindings;
+  const names = [];
+  if (decl.importClause?.name) names.push(decl.importClause.name.text);
+  if (bindings && ts.isNamedImports(bindings)) {
+    for (const el of bindings.elements) names.push(el.name.text);
+  } else if (bindings && ts.isNamespaceImport(bindings)) {
+    names.push(bindings.name.text);
+  }
+  return names;
+}
+
+// src/pieces.ts
+function templatePieces(ts, tpl, sf) {
+  if (ts.isNoSubstitutionTemplateLiteral(tpl)) {
+    return [{ kind: "static", text: tpl.text, 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 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 });
+  });
+  return pieces;
+}
+function templateAt(ts, sf, pos) {
+  let 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;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return found;
+}
+
+// src/hover.ts
+function componentQuickInfo(ts, ls, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return void 0;
+  const template = templateAt(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 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);
+  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));
+  let hit;
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.kind === "Component" && node.tag) {
+        const openStart = node.loc.start + 1;
+        if (within(position, openStart, node.tag.length)) {
+          hit = { name: node.tag.split(".")[0], start: openStart };
+        }
+      }
+      if (!hit && "children" in node && node.children) walk(node.children);
+      if (hit) return;
+    }
+  };
+  walk(root.children);
+  return hit;
+}
+function within(pos, start, length) {
+  return pos >= start && pos <= start + length;
+}
+
+// src/infer.ts
+var EVENT_TYPES = {
+  click: "MouseEvent",
+  dblclick: "MouseEvent",
+  mousedown: "MouseEvent",
+  mouseup: "MouseEvent",
+  mousemove: "MouseEvent",
+  mouseenter: "MouseEvent",
+  mouseleave: "MouseEvent",
+  mouseover: "MouseEvent",
+  mouseout: "MouseEvent",
+  contextmenu: "MouseEvent",
+  keydown: "KeyboardEvent",
+  keyup: "KeyboardEvent",
+  keypress: "KeyboardEvent",
+  input: "InputEvent",
+  beforeinput: "InputEvent",
+  change: "Event",
+  submit: "SubmitEvent",
+  focus: "FocusEvent",
+  blur: "FocusEvent",
+  focusin: "FocusEvent",
+  focusout: "FocusEvent",
+  pointerdown: "PointerEvent",
+  pointerup: "PointerEvent",
+  pointermove: "PointerEvent",
+  pointerenter: "PointerEvent",
+  pointerleave: "PointerEvent",
+  wheel: "WheelEvent",
+  scroll: "Event",
+  drag: "DragEvent",
+  drop: "DragEvent",
+  touchstart: "TouchEvent",
+  touchend: "TouchEvent",
+  touchmove: "TouchEvent",
+  animationend: "AnimationEvent",
+  transitionend: "TransitionEvent"
+};
+var TAG_ELEMENTS = {
+  a: "HTMLAnchorElement",
+  area: "HTMLAreaElement",
+  audio: "HTMLAudioElement",
+  br: "HTMLBRElement",
+  button: "HTMLButtonElement",
+  canvas: "HTMLCanvasElement",
+  data: "HTMLDataElement",
+  datalist: "HTMLDataListElement",
+  dialog: "HTMLDialogElement",
+  div: "HTMLDivElement",
+  dl: "HTMLDListElement",
+  embed: "HTMLEmbedElement",
+  fieldset: "HTMLFieldSetElement",
+  form: "HTMLFormElement",
+  h1: "HTMLHeadingElement",
+  h2: "HTMLHeadingElement",
+  h3: "HTMLHeadingElement",
+  h4: "HTMLHeadingElement",
+  h5: "HTMLHeadingElement",
+  h6: "HTMLHeadingElement",
+  hr: "HTMLHRElement",
+  iframe: "HTMLIFrameElement",
+  img: "HTMLImageElement",
+  input: "HTMLInputElement",
+  label: "HTMLLabelElement",
+  legend: "HTMLLegendElement",
+  li: "HTMLLIElement",
+  link: "HTMLLinkElement",
+  map: "HTMLMapElement",
+  menu: "HTMLMenuElement",
+  meter: "HTMLMeterElement",
+  object: "HTMLObjectElement",
+  ol: "HTMLOListElement",
+  optgroup: "HTMLOptGroupElement",
+  option: "HTMLOptionElement",
+  output: "HTMLOutputElement",
+  p: "HTMLParagraphElement",
+  picture: "HTMLPictureElement",
+  pre: "HTMLPreElement",
+  progress: "HTMLProgressElement",
+  q: "HTMLQuoteElement",
+  select: "HTMLSelectElement",
+  slot: "HTMLSlotElement",
+  source: "HTMLSourceElement",
+  span: "HTMLSpanElement",
+  table: "HTMLTableElement",
+  tbody: "HTMLTableSectionElement",
+  td: "HTMLTableCellElement",
+  template: "HTMLTemplateElement",
+  textarea: "HTMLTextAreaElement",
+  tfoot: "HTMLTableSectionElement",
+  th: "HTMLTableCellElement",
+  thead: "HTMLTableSectionElement",
+  time: "HTMLTimeElement",
+  tr: "HTMLTableRowElement",
+  track: "HTMLTrackElement",
+  ul: "HTMLUListElement",
+  video: "HTMLVideoElement"
+};
+function holeRoles(nodes, out) {
+  const renderChildren = (node, role) => {
+    if ("children" in node && node.children) {
+      for (const child of node.children) if (child.kind === "Expression") out.set(child.hole, role);
+    }
+  };
+  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 });
+      }
+      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 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 eachHole = propHole("each");
+        if (node.tag === "For" && eachHole !== void 0) renderChildren(node, { kind: "each", eachHole });
+        if (node.tag === "Index" && eachHole !== void 0) renderChildren(node, { kind: "indexEach", eachHole });
+        const whenHole = propHole("when");
+        if (node.tag === "Show" && whenHole !== void 0) renderChildren(node, { kind: "show", whenHole });
+      }
+    }
+    if ("children" in node && node.children) holeRoles(node.children, out);
+  }
+}
+function resolveGlobalType(ts, checker, location, 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) {
+  const map = resolveGlobalType(ts, checker, location, "HTMLElementTagNameMap");
+  const prop = map?.getProperty(tag.toLowerCase());
+  const t = prop ? checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration ?? location) : void 0;
+  return t ?? resolveGlobalType(ts, checker, location, "HTMLElement");
+}
+function inferParamAt(ts, program, sf, position) {
+  const template = templateAt(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 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);
+  const role = roles.get(holeIndex);
+  if (!role) return void 0;
+  const fn = holeExprs[holeIndex];
+  if (!ts.isArrowFunction(fn) && !ts.isFunctionExpression(fn)) return void 0;
+  const param = fn.parameters[0];
+  if (!param || !ts.isIdentifier(param.name) || param.type) return void 0;
+  const paramName = param.name.text;
+  const id = identifierAt(ts, sf, position);
+  if (!id || id.text !== paramName || !contains(fn, id)) return void 0;
+  const checker = program.getTypeChecker();
+  let typeText;
+  let type;
+  if (role.kind === "event") {
+    const name = EVENT_TYPES[role.event] ?? "Event";
+    typeText = name;
+    type = resolveGlobalType(ts, checker, fn, name);
+  } else if (role.kind === "refEl") {
+    type = resolveElementType(ts, checker, fn, role.tag);
+    typeText = type ? checker.typeToString(type) : TAG_ELEMENTS[role.tag.toLowerCase()] ?? "HTMLElement";
+    if (!type) type = resolveGlobalType(ts, checker, fn, typeText);
+  } else if (role.kind === "show") {
+    type = checker.getNonNullableType(checker.getTypeAtLocation(holeExprs[role.whenHole]));
+    typeText = checker.typeToString(type);
+  } else if (role.kind === "indexEach") {
+    const elem = checker.getTypeAtLocation(holeExprs[role.eachHole]).getNumberIndexType();
+    if (elem) typeText = `() => ${checker.typeToString(elem)}`;
+  } else {
+    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) };
+}
+function paramQuickInfo(ts, ls, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return void 0;
+  const info = inferParamAt(ts, program, sf, position);
+  if (!info) return void 0;
+  return {
+    kind: ts.ScriptElementKind.parameterElement,
+    kindModifiers: "",
+    textSpan: { start: info.start, length: info.length },
+    displayParts: [
+      { text: "(", kind: "punctuation" },
+      { text: "parameter", kind: "text" },
+      { text: ")", kind: "punctuation" },
+      { text: " ", kind: "space" },
+      { text: info.paramName, kind: "parameterName" },
+      { text: ":", kind: "punctuation" },
+      { text: " ", kind: "space" },
+      { text: info.typeText, kind: "text" }
+    ],
+    documentation: [{ text: "Inferred by Fluixi from the html`` template.", kind: "text" }]
+  };
+}
+function identifierAt(ts, sf, pos) {
+  let found;
+  const visit = (node) => {
+    if (found) return;
+    if (pos >= node.getStart(sf) && pos <= node.getEnd()) {
+      if (ts.isIdentifier(node)) found = node;
+      node.forEachChild(visit);
+    }
+  };
+  sf.forEachChild(visit);
+  return found;
+}
+function contains(outer, inner) {
+  return inner.getStart() >= outer.getStart() && inner.getEnd() <= outer.getEnd();
+}
+
+// src/props.ts
+function componentPropCompletions(ts, ls, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return void 0;
+  const template = templateAt(ts, sf, position);
+  if (!template) return void 0;
+  const comp = componentTagAtAttrArea(ts, sf, template.template, position);
+  if (!comp || !comp.tag) return void 0;
+  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));
+  }
+  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);
+  if (!propsType) return void 0;
+  const already = new Set(comp.attributeNames);
+  const entries = [];
+  for (const p2 of propsType.getProperties()) {
+    const name = p2.getName();
+    if (name === "children" || already.has(name)) continue;
+    entries.push(propEntry(ts, name));
+  }
+  return entries.length ? entries : void 0;
+}
+function componentPropHover(ts, ls, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return void 0;
+  const template = templateAt(ts, sf, position);
+  if (!template) return void 0;
+  const hit = propNameAt(ts, sf, template.template, position);
+  if (!hit) return void 0;
+  let typeText;
+  const cf = CONTROL_FLOW_PROP_TYPES[hit.tag];
+  if (cf) {
+    typeText = cf[hit.prop];
+    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 sym = propsType && propsType.getProperty(hit.prop);
+    if (!sym) return void 0;
+    typeText = checker.typeToString(checker.getTypeOfSymbolAtLocation(sym, sym.valueDeclaration ?? decl));
+  }
+  if (!typeText) return void 0;
+  return {
+    kind: ts.ScriptElementKind.memberVariableElement,
+    kindModifiers: "",
+    textSpan: { start: hit.start, length: hit.prop.length },
+    displayParts: [
+      { text: "(", kind: "punctuation" },
+      { text: "property", kind: "text" },
+      { text: ")", kind: "punctuation" },
+      { text: " ", kind: "space" },
+      { text: hit.prop, kind: "propertyName" },
+      { text: ":", kind: "punctuation" },
+      { text: " ", kind: "space" },
+      { text: typeText, kind: "text" }
+    ],
+    documentation: []
+  };
+}
+function propNameAt(ts, sf, tpl, position) {
+  const { root } = k(templatePieces(ts, tpl, sf));
+  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 };
+          }
+        }
+      }
+      if (!hit && "children" in node && node.children) walk(node.children);
+      if (hit) return;
+    }
+  };
+  walk(root.children);
+  return hit;
+}
+var CONTROL_FLOW_PROP_TYPES = {
+  Show: { when: "T", fallback: "JSX.Element", keyed: "boolean" },
+  For: { each: "readonly T[] | undefined | null", fallback: "JSX.Element", by: "(item: T) => unknown" },
+  Index: { each: "readonly T[] | undefined | null", fallback: "JSX.Element" },
+  Switch: { fallback: "JSX.Element" },
+  Match: { when: "T" },
+  Suspense: { fallback: "JSX.Element" },
+  SuspenseList: { revealOrder: '"forwards" | "backwards" | "together"', tail: '"collapsed" | "hidden"' },
+  Portal: { mount: "Node", useShadow: "boolean", isSVG: "boolean" },
+  ErrorBoundary: { fallback: "JSX.Element | ((err: unknown, reset: () => void) => JSX.Element)" },
+  Dynamic: { component: "Component | string" },
+  Await: { value: "Promise<T> | (() => Promise<T>)", fallback: "JSX.Element" }
+};
+var CONTROL_FLOW_PROPS = {
+  Show: ["when", "fallback", "keyed"],
+  For: ["each", "fallback", "by"],
+  Index: ["each", "fallback"],
+  Switch: ["fallback"],
+  Match: ["when"],
+  Suspense: ["fallback"],
+  SuspenseList: ["revealOrder", "tail"],
+  Portal: ["mount", "useShadow", "isSVG"],
+  ErrorBoundary: ["fallback"],
+  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 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());
+  }
+  return void 0;
+}
+function componentTagAtAttrArea(ts, sf, tpl, position) {
+  const { root } = k(templatePieces(ts, tpl, sf));
+  let hit;
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.kind === "Component") {
+        const c = node;
+        const openStart = c.loc.start + 1 + (c.tag ? c.tag.length : 0);
+        const openEnd = firstChildOrCloseStart(c);
+        if (position > openStart && position <= openEnd) {
+          hit = { tag: c.tag, attributeNames: attributeNames(c) };
+        }
+      }
+      if (!hit && "children" in node && node.children) walk(node.children);
+      if (hit) return;
+    }
+  };
+  walk(root.children);
+  return hit;
+}
+function firstChildOrCloseStart(c) {
+  if (c.selfClosing) return c.loc.end;
+  const first = c.children[0];
+  return first ? first.loc.start : c.loc.end;
+}
+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);
+  }
+  return out;
+}
+
+// src/completion.ts
+function paramMemberCompletions(ts, ls, fileName, position) {
+  const program = ls.getProgram();
+  const sf = program?.getSourceFile(fileName);
+  if (!program || !sf) return void 0;
+  const access = propertyAccessAt(ts, sf, position);
+  if (!access || !ts.isIdentifier(access.expression)) return void 0;
+  const info = inferParamAt(ts, program, sf, access.expression.getStart(sf));
+  if (!info || info.paramName !== access.expression.text || !info.type) return void 0;
+  const checker = program.getTypeChecker();
+  const already = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const p2 of checker.getApparentType(info.type).getProperties()) {
+    const name = p2.getName();
+    if (already.has(name) || name.startsWith("__")) continue;
+    already.add(name);
+    entries.push({
+      name,
+      kind: memberKind(ts, p2),
+      kindModifiers: "",
+      sortText: "0_" + name,
+      insertText: name
+    });
+  }
+  return entries.length ? entries : void 0;
+}
+function memberKind(ts, sym) {
+  if (sym.flags & ts.SymbolFlags.Method) return ts.ScriptElementKind.memberFunctionElement;
+  return ts.ScriptElementKind.memberVariableElement;
+}
+function propertyAccessAt(ts, sf, position) {
+  let found;
+  const visit = (node) => {
+    if (position < node.getFullStart() || position > node.getEnd()) return;
+    if (ts.isPropertyAccessExpression(node) && position > node.expression.getEnd() && position <= node.getEnd()) {
+      found = node;
+    }
+    node.forEachChild(visit);
+  };
+  sf.forEachChild(visit);
+  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;
+  };
+  gen += PRELUDE;
+  for (const tpl of templates) {
+    copy(tpl.node.getStart(sf));
+    gen = emitTemplate(ts, sf, tpl, gen, segments, srcText);
+    src = tpl.node.getEnd();
+  }
+  copy(srcText.length);
+  return { text: gen, segments };
+}
+function isFn(ts, node) {
+  return ts.isArrowFunction(node) || ts.isFunctionExpression(node);
+}
+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 });
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return out;
+}
+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;
+  };
+  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);
+        }
+      }
+    }
+    if ("children" in node && node.children) analyze(node.children, roles, consumed);
+  }
+}
+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";
+            }
+          });
+        } else if (a.kind === "PropertyBinding") {
+          entry(a.loc.start + 1, a.name, () => putHole(a.hole));
+        }
+      }
+      gen += " })";
+    };
+  }
+  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;
+}
+
+// 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);
+          };
+        }
+        const value = Reflect.get(target, prop, receiver);
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+    });
+    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;
+}
+
+// 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/index.ts
+function init(modules) {
+  const ts = modules.typescript;
+  return {
+    create(info) {
+      const ls = info.languageService;
+      let vs;
+      try {
+        vs = new VirtualService(ts, info.languageServiceHost);
+      } catch {
+        vs = void 0;
+      }
+      const proxy = /* @__PURE__ */ Object.create(null);
+      for (const key of Object.keys(ls)) {
+        const member = ls[key];
+        proxy[key] = typeof member === "function" ? member.bind(ls) : member;
+      }
+      const completionList = (entries) => ({
+        isGlobalCompletion: false,
+        isMemberCompletion: false,
+        isNewIdentifierLocation: true,
+        entries
+      });
+      const IMPLICIT_ANY = /* @__PURE__ */ new Set([7006, 7044]);
+      const reliableFilter = (fileName, diagnostics) => {
+        const program = ls.getProgram();
+        const sourceFile = program?.getSourceFile(fileName);
+        if (!program || !sourceFile) return diagnostics;
+        const used = usedComponentTags(ts, sourceFile);
+        return diagnostics.filter((d) => {
+          if (used.size > 0 && shouldSuppress(ts, sourceFile, d, used)) return false;
+          if (IMPLICIT_ANY.has(d.code) && d.start !== void 0 && inferParamAt(ts, program, sourceFile, d.start)) return false;
+          return true;
+        });
+      };
+      const holeDiagnostics = (fileName, get) => {
+        if (!vs || !vs.segmentsFor(fileName)) return [];
+        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;
+        } catch {
+          return [];
+        }
+      };
+      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);
+          if (prop) return prop;
+        } catch {
+        }
+        try {
+          const inferred = paramQuickInfo(ts, ls, fileName, position);
+          if (inferred) return inferred;
+        } catch {
+        }
+        return ls.getQuickInfoAtPosition(fileName, position) ?? componentQuickInfo(ts, ls, fileName, position);
+      };
+      proxy.getCompletionsAtPosition = (fileName, position, options, formatting) => {
+        try {
+          const props = componentPropCompletions(ts, ls, fileName, position);
+          if (props) return completionList(props);
+        } catch {
+        }
+        try {
+          const members = paramMemberCompletions(ts, ls, fileName, position);
+          if (members) return completionList(members);
+        } catch {
+        }
+        return ls.getCompletionsAtPosition(fileName, position, options, formatting);
+      };
+      return proxy;
+    }
+  };
+}
+module.exports = init;