@fluixi/compiler 1.0.0-alpha.83 → 1.0.0-alpha.85

package/dist/transform-RWDTQUF5.mjs

@@ -0,0 +1,893 @@
+/*! @fluixi/compiler v1.0.0-alpha.85 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+import {
+  analyzeStatic,
+  buildJsxIR,
+  collapseStrategies,
+  collectSourceEdits,
+  declaredNames,
+  imperativeBackend,
+  inlineTemplates,
+  isDeferred,
+  isReactiveShape,
+  lowerTemplate,
+  mayHaveReactiveCall,
+  resolveComponentSources,
+  resolveReactiveBindings,
+  shapeOf
+} from "./chunk-6DB5FXS4.mjs";
+import {
+  CORE_CONTROL_FLOW,
+  DOM_CONTROL_FLOW,
+  INTRINSICS,
+  ROUTER_COMPONENTS,
+  createComponentResolver,
+  isIntrinsicName,
+  mayHaveIntrinsic
+} from "./chunk-4PLHS2FP.mjs";
+import {
+  MagicString
+} from "./chunk-RUDJDZAA.mjs";
+import "./chunk-G6QC2WRJ.mjs";
+
+// src/transform/templates.ts
+import { parse as parse2 } from "@babel/parser";
+
+// src/lower/compile-template.ts
+function compilePieces(pieces, holes, options = {}) {
+  const used = /* @__PURE__ */ new Set();
+  const ir = lowerTemplate(pieces, [...holes], used, {
+    svg: options.svg,
+    ...options.sourceFile ? { sourceFile: options.sourceFile } : {},
+    ...options.positionAt ? { positionAt: options.positionAt } : {}
+  });
+  analyzeStatic(ir);
+  resolveComponentSources(ir, {
+    resolver: createComponentResolver(options.resolve ?? []),
+    modules: {
+      controlFlowModule: options.controlFlowModule ?? "@fluixi/dom",
+      coreModule: options.coreModule ?? "@fluixi/core",
+      routerModule: options.routerModule ?? "@fluixi/core/router"
+    },
+    strategyFor: (node) => node.load
+  });
+  collapseStrategies(ir);
+  const { code, imports, templates } = imperativeBackend.emit(ir, {
+    templateClone: options.templateClone,
+    partialTemplates: options.partialTemplates
+  });
+  for (const symbol of imports) used.add(symbol);
+  if (options.hoistTemplates) return { code, imports: [...used], ir, templates };
+  return { code: inlineTemplates(code, templates), imports: [...used], ir };
+}
+
+// src/transform/bindings.ts
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function declared(node, out) {
+  switch (node.type) {
+    case "ImportDeclaration":
+      for (const s of node.specifiers) patternNames(s.local, out);
+      return;
+    case "VariableDeclaration":
+      for (const d of node.declarations) patternNames(d.id, out);
+      return;
+    case "FunctionDeclaration":
+    case "ClassDeclaration":
+      patternNames(node.id, out);
+      return;
+    case "ExportNamedDeclaration":
+    case "ExportDefaultDeclaration":
+      if (node.declaration) declared(node.declaration, out);
+      return;
+  }
+}
+function moduleBindings(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) declared(statement, names);
+  return names;
+}
+
+// src/transform/props.ts
+import { parse } from "@babel/parser";
+
+// src/analyze/props-destructure.ts
+function patternNames2(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames2(p.argument, out);
+        else patternNames2(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames2(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames2(node.left, out);
+      return;
+    case "RestElement":
+      patternNames2(node.argument, out);
+      return;
+  }
+}
+function isSafeDefault(node) {
+  switch (node.type) {
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+    case "NullLiteral":
+    case "BigIntLiteral":
+    case "RegExpLiteral":
+    case "Identifier":
+      return true;
+    // ESTree spells every literal as `Literal`; both shapes reach this analysis.
+    case "Literal":
+      return true;
+    case "TemplateLiteral":
+      return node.expressions.every(isSafeDefault);
+    case "UnaryExpression":
+      return isSafeDefault(node.argument);
+    case "MemberExpression":
+      return false;
+    default:
+      return false;
+  }
+}
+function walk(root, visit) {
+  if (!root || typeof root !== "object") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "range" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) {
+      for (const item of value) if (item && typeof item === "object") walk(item, visit);
+    } else if (value && typeof value === "object" && typeof value.type === "string") {
+      walk(value, visit);
+    }
+  }
+}
+function reassignedNames(body) {
+  const written = /* @__PURE__ */ new Set();
+  walk(body, (node) => {
+    if (node.type === "AssignmentExpression") patternNames2(node.left, written);
+    else if (node.type === "UpdateExpression") {
+      const arg = node.argument;
+      if (arg?.type === "Identifier") written.add(arg.name);
+    }
+  });
+  return written;
+}
+function shadowedNames(body, candidates) {
+  const shadowed = /* @__PURE__ */ new Set();
+  const note = (node) => {
+    const names = /* @__PURE__ */ new Set();
+    patternNames2(node, names);
+    for (const n of names) if (candidates.has(n)) shadowed.add(n);
+  };
+  walk(body, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        note(node.id);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        note(node.id);
+        for (const p of node.params ?? []) note(p);
+        return;
+      case "CatchClause":
+        note(node.param);
+        return;
+      case "ClassDeclaration":
+      case "ClassExpression":
+        note(node.id);
+        return;
+    }
+  });
+  return shadowed;
+}
+function collect(pattern, path, plan) {
+  for (const property of pattern.properties ?? []) {
+    if (property.type === "RestElement") {
+      const argument = property.argument;
+      if (argument?.type !== "Identifier" || path.length > 0) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames2(argument, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "rest" });
+        continue;
+      }
+      plan.rest = { name: argument.name, keys: [] };
+      continue;
+    }
+    if (property.computed) {
+      const names2 = /* @__PURE__ */ new Set();
+      patternNames2(property.value, names2);
+      for (const name of names2) plan.bails.push({ name, reason: "computed" });
+      continue;
+    }
+    const key = property.key;
+    const propertyName = key.type === "Identifier" ? key.name : key.value;
+    let value = property.value;
+    let fallback;
+    if (value.type === "AssignmentPattern") {
+      fallback = value.right;
+      value = value.left;
+    }
+    const here = [...path, propertyName];
+    if (value.type === "Identifier") {
+      if (fallback && !isSafeDefault(fallback)) {
+        plan.bails.push({ name: value.name, reason: "unsafe-default" });
+        continue;
+      }
+      plan.reads.push({ name: value.name, path: here, ...fallback ? { fallback } : {} });
+      continue;
+    }
+    if (value.type === "ObjectPattern") {
+      if (fallback) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames2(value, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "unsafe-default" });
+        continue;
+      }
+      collect(value, here, plan);
+      continue;
+    }
+    const names = /* @__PURE__ */ new Set();
+    patternNames2(value, names);
+    for (const name of names) plan.bails.push({ name, reason: "computed" });
+  }
+}
+function planPropsDestructure(pattern, body) {
+  const plan = { reads: [], bails: [] };
+  if (pattern?.type !== "ObjectPattern") return plan;
+  collect(pattern, [], plan);
+  if (plan.rest) {
+    if (body?.type !== "BlockStatement") {
+      plan.bails.push({ name: plan.rest.name, reason: "rest" });
+      delete plan.rest;
+    } else {
+      plan.rest.keys = (pattern.properties ?? []).filter((p) => p.type !== "RestElement" && !p.computed).map((p) => {
+        const key = p.key;
+        return key.type === "Identifier" ? key.name : key.value;
+      });
+    }
+  }
+  if (plan.reads.length === 0 && !plan.rest) return plan;
+  const candidates = new Set(plan.reads.map((r) => r.name));
+  if (plan.rest) candidates.add(plan.rest.name);
+  const written = reassignedNames(body);
+  const shadowed = shadowedNames(body, candidates);
+  const kept = [];
+  for (const read of plan.reads) {
+    if (written.has(read.name)) plan.bails.push({ name: read.name, reason: "reassigned" });
+    else if (shadowed.has(read.name)) plan.bails.push({ name: read.name, reason: "shadowed" });
+    else kept.push(read);
+  }
+  plan.reads = kept;
+  if (plan.rest && written.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "reassigned" });
+    delete plan.rest;
+  } else if (plan.rest && shadowed.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "shadowed" });
+    delete plan.rest;
+  }
+  return plan;
+}
+function explainBail(reason) {
+  switch (reason) {
+    case "rest":
+      return "this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters";
+    case "computed":
+      return "the property is not known until it runs";
+    case "reassigned":
+      return "the binding is assigned to, and props are read-only";
+    case "shadowed":
+      return "an inner scope binds the same name";
+    case "unsafe-default":
+      return "the default would have to run again on every read";
+  }
+}
+
+// src/transform/props.ts
+function walk2(root, visit, parent = null) {
+  if (!root || typeof root !== "object" || typeof root.type !== "string") return;
+  if (root.type.startsWith("TS")) return;
+  if (visit(root, parent) === false) return;
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) {
+      for (const item of value) walk2(item, visit, root);
+    } else if (value && typeof value === "object") {
+      walk2(value, visit, root);
+    }
+  }
+}
+function isComponentName(name) {
+  return !!name && name[0] >= "A" && name[0] <= "Z";
+}
+function componentFunctions(program) {
+  const found = [];
+  walk2(program, (node) => {
+    if (node.type === "FunctionDeclaration" && isComponentName(node.id?.name)) {
+      found.push(node);
+      return;
+    }
+    if (node.type === "VariableDeclarator" && isComponentName(node.id?.name)) {
+      const init = node.init;
+      if (init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) found.push(init);
+    }
+  });
+  return found;
+}
+function usedNames(fn) {
+  const names = /* @__PURE__ */ new Set();
+  walk2(fn, (node) => {
+    if (node.type === "Identifier") names.add(node.name);
+  });
+  return names;
+}
+function isReferencePosition(node, parent) {
+  if (!parent) return true;
+  switch (parent.type) {
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return !(parent.property === node && !parent.computed);
+    case "ObjectProperty":
+    case "ObjectMethod":
+    case "ClassProperty":
+    case "ClassMethod":
+      return !(parent.key === node && !parent.computed);
+    case "LabeledStatement":
+    case "BreakStatement":
+    case "ContinueStatement":
+      return parent.label !== node;
+    case "ImportSpecifier":
+    case "ExportSpecifier":
+      return false;
+    default:
+      return true;
+  }
+}
+function collectPropsEdits(program, code, options = {}) {
+  const edits = [];
+  const diagnostics = [];
+  const used = /* @__PURE__ */ new Set();
+  for (const fn of componentFunctions(program)) {
+    const pattern = fn.params?.[0];
+    if (pattern?.type !== "ObjectPattern") continue;
+    const plan = planPropsDestructure(pattern, fn.body);
+    for (const b of plan.bails) {
+      diagnostics.push({ name: b.name, reason: b.reason, message: explainBail(b.reason), start: pattern.start });
+    }
+    if (plan.bails.length > 0) continue;
+    if (plan.reads.length === 0 && !plan.rest) continue;
+    const taken = usedNames(fn);
+    let parameter = options.parameterName ?? "props";
+    while (taken.has(parameter)) parameter = `_${parameter}`;
+    const replacement = /* @__PURE__ */ new Map();
+    for (const read of plan.reads) {
+      const access = `${parameter}.${read.path.join(".")}`;
+      const fallback = read.fallback;
+      replacement.set(
+        read.name,
+        fallback ? `(${access} === undefined ? ${code.slice(fallback.start, fallback.end)} : ${access})` : access
+      );
+    }
+    const annotation = pattern.typeAnnotation;
+    edits.push({ start: pattern.start, end: annotation?.start ?? pattern.end, code: parameter });
+    if (plan.rest) {
+      const keys = plan.rest.keys.map((k) => JSON.stringify(k)).join(", ");
+      const body = fn.body;
+      edits.push({
+        start: body.start + 1,
+        end: body.start + 1,
+        code: `
+  const [, ${plan.rest.name}] = splitProps(${parameter}, [${keys}]);`
+      });
+      used.add("splitProps");
+    }
+    const matches = [];
+    walk2(fn.body, (node, parent) => {
+      if (node.type !== "Identifier") return void 0;
+      const text = replacement.get(node.name);
+      if (!text) return void 0;
+      const shorthand = parent?.type === "ObjectProperty" && parent.shorthand && parent.value === node;
+      if (!shorthand && !isReferencePosition(node, parent)) return void 0;
+      const path = plan.reads.find((r) => r.name === node.name).path;
+      matches.push({ node, parent: shorthand ? parent : null, text, property: path[path.length - 1] });
+      return void 0;
+    });
+    for (const match of matches) {
+      if (match.parent) {
+        edits.push({ start: match.parent.start, end: match.parent.end, code: `${match.node.name}: ${match.text}` });
+      } else {
+        edits.push({ start: match.node.start, end: match.node.end, code: match.text });
+      }
+      asMemberRead(match.node, parameter, match.property);
+    }
+  }
+  return { edits, diagnostics, used };
+}
+function asMemberRead(node, parameter, property) {
+  node.type = "MemberExpression";
+  node.computed = false;
+  node.optional = false;
+  node.object = { type: "Identifier", name: parameter, start: node.start, end: node.start };
+  node.property = { type: "Identifier", name: property, start: node.end, end: node.end };
+  delete node["name"];
+}
+function transformProps(code, filename = "module.tsx", options = {}) {
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"],
+    errorRecovery: true
+  });
+  const { edits, diagnostics, used } = collectPropsEdits(ast.program, code, options);
+  const source = new MagicString(code);
+  for (const e of edits) {
+    if (e.start === e.end) source.appendLeft(e.start, e.code);
+    else source.overwrite(e.start, e.end, e.code);
+  }
+  if (used.has("splitProps") && !moduleBindings(ast.program).has("splitProps")) {
+    source.prepend(`import { splitProps } from ${JSON.stringify(options.runtimeModule ?? "@fluixi/dom")};
+`);
+  }
+  return {
+    code: source.toString(),
+    map: source.generateMap({ source: filename, includeContent: true, hires: true }),
+    diagnostics,
+    rewritten: edits.filter((e) => e.code !== (options.parameterName ?? "props")).length
+  };
+}
+
+// src/transform/intrinsics.ts
+function walk3(root, visit) {
+  if (!root || typeof root !== "object" || typeof root.type !== "string") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) for (const item of value) walk3(item, visit);
+    else if (value && typeof value === "object") walk3(value, visit);
+  }
+}
+function collectIntrinsicEdits(program) {
+  const edits = [];
+  const diagnostics = [];
+  const imports = /* @__PURE__ */ new Map();
+  const reported = /* @__PURE__ */ new Set();
+  const { shadowed } = resolveReactiveBindings(program);
+  walk3(program, (node) => {
+    if (node.type !== "CallExpression") return;
+    const callee = node.callee;
+    if (callee?.type !== "Identifier") return;
+    const name = callee.name;
+    if (!isIntrinsicName(name)) return;
+    if (shadowed.has(name)) {
+      if (!reported.has(name)) {
+        reported.add(name);
+        diagnostics.push({
+          name,
+          message: `${name} is reserved for the compiler, and this module binds it. The call keeps your binding's meaning; rename it to use the intrinsic.`,
+          start: callee.start
+        });
+      }
+      return;
+    }
+    const intrinsic = INTRINSICS[name];
+    edits.push({ start: callee.start, end: callee.end, code: intrinsic.export });
+    const forModule = imports.get(intrinsic.module) ?? /* @__PURE__ */ new Set();
+    forModule.add(intrinsic.export);
+    imports.set(intrinsic.module, forModule);
+  });
+  return { edits, diagnostics, imports };
+}
+function intrinsicImports(result, bound) {
+  const lines = [];
+  for (const [module, names] of [...result.imports].sort(([a], [b]) => a.localeCompare(b))) {
+    const wanted = [...names].filter((name) => !bound.has(name)).sort();
+    if (wanted.length) lines.push(`import { ${wanted.join(", ")} } from ${JSON.stringify(module)};`);
+  }
+  return lines.length ? `${lines.join("\n")}
+` : "";
+}
+
+// src/transform/templates.ts
+var CONTROL_FLOW = new Set(DOM_CONTROL_FLOW);
+var CORE_ONLY = new Set(CORE_CONTROL_FLOW);
+var ROUTER = new Set(ROUTER_COMPONENTS);
+var REACTIVE = /* @__PURE__ */ new Set([
+  "createMemo",
+  "createEffect",
+  "createRenderEffect",
+  "createRoot",
+  "createSignal",
+  "onCleanup",
+  "batch",
+  "untrack"
+]);
+function walk4(node, visit, parent = null, key = "") {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const child of node) walk4(child, visit, parent, key);
+    return;
+  }
+  if (typeof node.type === "string") visit(node, parent, key);
+  for (const k of Object.keys(node)) {
+    if (k === "loc" || k === "leadingComments" || k === "trailingComments") continue;
+    walk4(node[k], visit, typeof node.type === "string" ? node : parent, k);
+  }
+}
+var isJsx = (node) => node.type === "JSXElement" || node.type === "JSXFragment";
+function isJsxRoot(node, parent, key) {
+  if (!isJsx(node)) return false;
+  return !(parent && isJsx(parent) && key === "children");
+}
+function isTemplateTag(node, litTag) {
+  return node.type === "TaggedTemplateExpression" && node.tag?.type === "Identifier" && (node.tag.name === litTag || node.tag.name === "svg");
+}
+function outermost(list) {
+  return list.filter(
+    (e) => !list.some(
+      (o) => o !== e && o.start <= e.start && o.end >= e.end && o.end - o.start > e.end - e.start && // An insertion at either edge of the container sits beside it, not inside it, so
+      // it is not something the container's code already folded in. A statement can
+      // start where its callee starts (`$effect(…)`) and a declarator can end where its
+      // JSX ends (`const Row = () => <b/>`).
+      !(e.start === e.end && (e.start === o.start || e.start === o.end))
+    )
+  );
+}
+function slice(code, start, end, edits) {
+  const inside = outermost(edits.filter((e) => e.start >= start && e.end <= end)).sort((a, b) => b.start - a.start);
+  let out = code.slice(start, end);
+  for (const e of inside) out = out.slice(0, e.start - start) + e.code + out.slice(e.end - start);
+  return out;
+}
+function bindHole(code, expr, edits, keepPosition = false) {
+  const at = keepPosition ? expr.loc?.start : void 0;
+  const hole = {
+    code: slice(code, expr.start, expr.end, edits),
+    reactive: isReactiveShape(shapeOf(expr)),
+    // Where the `${…}` is, so a binding made from it can say so. The source map cannot:
+    // the whole template is one overwrite. Only when source locations were asked for.
+    ...at ? { at: { line: at.line, column: at.column } } : {}
+  };
+  if (expr.type === "ArrowFunctionExpression" && expr.body?.type !== "BlockStatement") {
+    hole.arrow = {
+      params: expr.params.map((p) => slice(code, p.start, p.end, edits)),
+      body: slice(code, expr.body.start, expr.body.end, edits),
+      bodyReactive: isReactiveShape(shapeOf(expr.body))
+    };
+  }
+  if (expr.type === "ObjectExpression") hole.object = true;
+  return hole;
+}
+function adoptTemplates(code, templates, hoisted) {
+  if (!templates || templates.length === 0) return code;
+  const rename = /* @__PURE__ */ new Map();
+  for (const tpl of templates) {
+    const key = `${tpl.svg ? "svg:" : ""}${tpl.html}`;
+    let name = hoisted.get(key);
+    if (!name) {
+      name = `_fxTmpl$${hoisted.size}`;
+      hoisted.set(key, name);
+    }
+    rename.set(tpl.id, name);
+  }
+  return code.replace(/_tmpl\$\d+/g, (id) => rename.get(id) ?? id);
+}
+function collectNeeds(node, out) {
+  if (node.kind === "component" && node.load && !node.source && isDeferred(node.load)) {
+    if (!out.ignoredLoad.has(node.name)) out.ignoredLoad.set(node.name, node.load);
+  }
+  if (node.kind === "component" && node.source) {
+    const src = node.source;
+    if (src.origin === "builtin") out.builtins.add(node.name);
+    else if (isDeferred(src.loading) && !out.resolved.has(node.name)) out.deferred.set(node.name, src);
+    else {
+      out.deferred.delete(node.name);
+      out.resolved.set(node.name, src);
+    }
+  }
+  if ("props" in node && node.props) {
+    for (const p of node.props) {
+      if (p.kind === "event" && p.event?.delegated) out.delegatedEvents.add(p.event.name);
+    }
+  }
+  if ("children" in node && node.children) for (const c of node.children) collectNeeds(c, out);
+}
+function deferrableImport(program, name) {
+  for (const statement of program.body ?? []) {
+    if (statement.type !== "ImportDeclaration") continue;
+    for (const specifier of statement.specifiers ?? []) {
+      if (specifier.local?.name !== name) continue;
+      if (specifier.type === "ImportNamespaceSpecifier") return void 0;
+      const exported = specifier.type === "ImportDefaultSpecifier" ? "default" : specifier.imported?.name ?? specifier.imported?.value;
+      return { module: statement.source.value, export: exported, declaration: statement, specifier };
+    }
+  }
+  return void 0;
+}
+function hasNamespaceImport(program, name) {
+  for (const statement of program.body ?? []) {
+    if (statement.type !== "ImportDeclaration") continue;
+    for (const specifier of statement.specifiers ?? []) {
+      if (specifier.type === "ImportNamespaceSpecifier" && specifier.local?.name === name) return true;
+    }
+  }
+  return false;
+}
+function usedAsValue(program, name, specifier) {
+  let seen = false;
+  walk4(program, (node) => {
+    if (seen || node.type !== "Identifier" || node.name !== name) return;
+    if (node.start === specifier.local?.start && node.end === specifier.local?.end) return;
+    seen = true;
+  });
+  return seen;
+}
+function strategyLiteral(s) {
+  const parts = [`kind: ${JSON.stringify(s.kind)}`];
+  if (s.kind === "visible" && s.rootMargin) parts.push(`rootMargin: ${JSON.stringify(s.rootMargin)}`);
+  if (s.kind === "interaction") parts.push(`events: ${JSON.stringify(s.events)}`);
+  if (s.kind === "media") parts.push(`query: ${JSON.stringify(s.query)}`);
+  return `{ ${parts.join(", ")} }`;
+}
+function positionsIn(code) {
+  const starts = [0];
+  for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) starts.push(i + 1);
+  return (offset) => {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+      const mid = low + high + 1 >> 1;
+      if (starts[mid] <= offset) low = mid;
+      else high = mid - 1;
+    }
+    return { line: low + 1, column: offset - starts[low] };
+  };
+}
+function toPieces(node) {
+  const pieces = [];
+  node.quasi.quasis.forEach((q, i) => {
+    pieces.push({ kind: "static", text: q.value.cooked ?? q.value.raw, start: q.start });
+    if (i < node.quasi.expressions.length) {
+      const e = node.quasi.expressions[i];
+      pieces.push({ kind: "hole", index: i, start: e.start, end: e.end });
+    }
+  });
+  return pieces;
+}
+function relativeToRoot(id, root) {
+  if (!root) return id;
+  const base = root.endsWith("/") ? root : `${root}/`;
+  return id.startsWith(base) ? id.slice(base.length) : id;
+}
+function transformTemplates(code, id, options = {}) {
+  const litTag = options.litTag ?? "html";
+  const format = options.format ?? "both";
+  const wantsLit = format !== "jsx";
+  const wantsJsx = format !== "lit";
+  const mayHaveTemplate = wantsLit && (code.includes(`${litTag}\``) || code.includes("svg`"));
+  const wantsIntrinsics = options.intrinsics !== false && mayHaveIntrinsic(code);
+  const wantsSources = options.sourceLocations === true && mayHaveReactiveCall(code);
+  const sourceName = relativeToRoot(id, options.sourceRoot);
+  if (!mayHaveTemplate && !(wantsJsx && code.includes("<")) && !wantsIntrinsics && !wantsSources) return null;
+  const ast = parse2(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript"],
+    errorRecovery: true
+  });
+  const found = [];
+  walk4(ast.program, (n, parent, key) => {
+    if (wantsLit && isTemplateTag(n, litTag)) found.push(n);
+    else if (wantsJsx && isJsxRoot(n, parent, key)) found.push(n);
+  });
+  const props = options.propsDestructure === false ? { edits: [], diagnostics: [], used: /* @__PURE__ */ new Set() } : collectPropsEdits(ast.program, code, { runtimeModule: options.runtimeModule });
+  const intrinsics = options.intrinsics === false ? { edits: [], diagnostics: [], imports: /* @__PURE__ */ new Map() } : collectIntrinsicEdits(ast.program);
+  const sources = options.sourceLocations === true ? collectSourceEdits(ast.program, sourceName) : { edits: [], marked: 0 };
+  const silent = found.length === 0 && props.edits.length === 0 && sources.edits.length === 0 && intrinsics.edits.length === 0 && intrinsics.diagnostics.length === 0 && props.diagnostics.length === 0;
+  if (silent) return null;
+  found.sort((a, b) => b.start - a.start || a.end - b.end);
+  const used = new Set(props.used);
+  const needs = {
+    builtins: /* @__PURE__ */ new Set(),
+    resolved: /* @__PURE__ */ new Map(),
+    deferred: /* @__PURE__ */ new Map(),
+    delegatedEvents: /* @__PURE__ */ new Set(),
+    ignoredLoad: /* @__PURE__ */ new Map(),
+    unresolved: /* @__PURE__ */ new Set(),
+    declared: declaredNames(ast.program)
+  };
+  const hoisted = /* @__PURE__ */ new Map();
+  const edits = [...props.edits, ...intrinsics.edits, ...sources.edits];
+  for (const node of found) {
+    const nested = found.some(
+      (o) => o !== node && o.start <= node.start && o.end >= node.end && o.end - o.start > node.end - node.start
+    );
+    if (isJsx(node)) {
+      edits.push({ start: node.start, end: node.end, code: compileJsx(code, node, edits, nested, used, needs, hoisted, options, sourceName) });
+      continue;
+    }
+    const holes = node.quasi.expressions.map(
+      (e) => bindHole(code, e, edits, options.sourceLocations === true)
+    );
+    const result = compilePieces(toPieces(node), holes, {
+      ...options,
+      hoistTemplates: true,
+      // A tag inside a template gets the same mark a JSX tag does. Without one, the nodes it
+      // makes are the only ones in the module carrying no mark, and they take whichever was
+      // left behind by the last declaration that did.
+      ...options.sourceLocations === true ? { sourceFile: sourceName, positionAt: positionsIn(code) } : {},
+      // Same defaults as the plugin, so moving a build over is not a rendering change.
+      templateClone: options.templateClone ?? true,
+      partialTemplates: nested ? false : options.partialTemplates ?? true,
+      svg: node.tag.name === "svg"
+    });
+    for (const symbol of result.imports) used.add(symbol);
+    collectNeeds(result.ir, needs);
+    edits.push({ start: node.start, end: node.end, code: adoptTemplates(result.code, result.templates, hoisted) });
+  }
+  const out = new MagicString(code);
+  for (const e of outermost(edits)) {
+    if (e.start === e.end) out.appendLeft(e.start, e.code);
+    else out.overwrite(e.start, e.end, e.code);
+  }
+  const bound = moduleBindings(ast.program);
+  const why = /* @__PURE__ */ new Map();
+  for (const [name] of needs.ignoredLoad) {
+    if (!bound.has(name)) why.set(name, "unsupplied");
+  }
+  for (const [name, strategy] of [...needs.ignoredLoad]) {
+    if (!bound.has(name)) continue;
+    const found2 = deferrableImport(ast.program, name);
+    if (!found2) {
+      why.set(name, hasNamespaceImport(ast.program, name) ? "namespace" : "local");
+      continue;
+    }
+    if (usedAsValue(ast.program, name, found2.specifier)) {
+      why.set(name, "value");
+      continue;
+    }
+    const rest = found2.declaration.specifiers.filter((sp) => sp !== found2.specifier);
+    const end = rest.length === 0 && code[found2.declaration.end] === "\n" ? found2.declaration.end + 1 : found2.declaration.end;
+    out.overwrite(
+      found2.declaration.start,
+      end,
+      rest.length === 0 ? "" : `import { ${rest.map((sp) => code.slice(sp.start, sp.end)).join(", ")} } from ${JSON.stringify(found2.declaration.source.value)};`
+    );
+    needs.deferred.set(name, { module: found2.module, export: found2.export, origin: "rule", loading: strategy });
+    bound.delete(name);
+    needs.ignoredLoad.delete(name);
+  }
+  const prologue = buildPrologue(used, needs, hoisted, bound, options);
+  if (prologue) out.prepend(prologue);
+  const runtimeImports = intrinsicImports(intrinsics, bound);
+  if (runtimeImports) out.prepend(runtimeImports);
+  const reasons = {
+    value: (name) => `${name} is used as a value here, not only as a tag, so its import has to stay — deferring would hand those references a lazy wrapper instead of the component. Defer it at the point it is rendered, or keep it eager.`,
+    namespace: (name) => `${name} came in through a namespace import, which has no single export to defer. Import ${name} by name.`,
+    local: (name) => `${name} is declared in this file, so there is no module to load separately. Move it to its own file and import it.`,
+    unsupplied: (name) => `nothing supplies ${name}, so there is no import to defer. Import it, or add a \`resolve\` rule for it.`
+  };
+  const loadDiagnostics = [...needs.ignoredLoad].map(([name, strategy]) => ({
+    name,
+    strategy,
+    message: `load:${strategy.kind} has no effect on <${name}>: ${reasons[why.get(name) ?? "unsupplied"](name)}`
+  }));
+  const unresolvedDiagnostics = [...needs.unresolved].map((name) => ({
+    name,
+    message: `<${name}> is not defined: nothing imports it and no \`resolve\` rule supplies it. This compiles to a reference to a name that does not exist, so the component renders nothing. Import ${name}, or add a \`resolve\` rule for it.`
+  }));
+  return {
+    code: out.toString(),
+    map: out.generateMap({ source: id, includeContent: true, hires: true }),
+    ...loadDiagnostics.length ? { loadDiagnostics } : {},
+    ...unresolvedDiagnostics.length ? { unresolvedDiagnostics } : {},
+    ...props.diagnostics.length ? { propsDiagnostics: props.diagnostics } : {},
+    ...intrinsics.diagnostics.length ? { intrinsicDiagnostics: intrinsics.diagnostics } : {}
+  };
+}
+function compileJsx(code, node, edits, nested, used, needs, hoisted, options, sourceFile) {
+  const ir = buildJsxIR(node, {
+    code: (n) => slice(code, n.start, n.end, edits),
+    used,
+    ...options.sourceLocations === true && sourceFile ? { sourceFile } : {}
+  });
+  analyzeStatic(ir);
+  const report = resolveComponentSources(ir, {
+    resolver: createComponentResolver(options.resolve ?? []),
+    // Without this the pass calls every author-imported component unresolved, and the
+    // report is unusable for diagnostics.
+    isBound: (name) => needs.declared.has(name),
+    modules: {
+      controlFlowModule: options.controlFlowModule ?? options.runtimeModule ?? "@fluixi/dom",
+      coreModule: options.coreModule ?? "@fluixi/core",
+      routerModule: options.routerModule ?? "@fluixi/core/router"
+    },
+    strategyFor: (n) => n.load
+  });
+  for (const name of report.unresolved) needs.unresolved.add(name);
+  collapseStrategies(ir);
+  const emitted = imperativeBackend.emit(ir, {
+    templateClone: options.templateClone ?? true,
+    partialTemplates: nested ? false : options.partialTemplates ?? true
+  });
+  for (const symbol of emitted.imports) used.add(symbol);
+  collectNeeds(ir, needs);
+  return adoptTemplates(emitted.code, emitted.templates, hoisted);
+}
+function buildPrologue(used, needs, hoisted, bound, options) {
+  const runtime = options.runtimeModule ?? "@fluixi/dom";
+  const core = options.coreModule ?? "@fluixi/core";
+  const groups = /* @__PURE__ */ new Map();
+  const add = (mod, name) => groups.set(mod, [...groups.get(mod) ?? [], name]);
+  const wanted = new Set(used);
+  for (const name of needs.builtins) wanted.add(name);
+  if (needs.delegatedEvents.size > 0) wanted.add("delegateEvents");
+  for (const name of [...wanted].sort()) {
+    if (bound.has(name)) continue;
+    if (REACTIVE.has(name)) add(options.reactiveModule ?? "@fluixi/reactive/signal", name);
+    else if (ROUTER.has(name)) add(options.routerModule ?? "@fluixi/core/router", name);
+    else if (CORE_ONLY.has(name)) add(core, name);
+    else if (CONTROL_FLOW.has(name)) add(options.controlFlowModule ?? runtime, name);
+    else add(runtime, name);
+  }
+  for (const [name, src] of needs.resolved) {
+    if (!bound.has(name)) add(src.module, src.export === "default" ? `default as ${name}` : name === src.export ? name : `${src.export} as ${name}`);
+  }
+  const lines = [];
+  for (const [mod, names] of groups) {
+    lines.push(`import { ${names.join(", ")} } from ${JSON.stringify(mod)};`);
+  }
+  const lazy = [...needs.deferred].filter(([name]) => !bound.has(name));
+  if (lazy.length > 0) {
+    if (!bound.has("deferred")) lines.push(`import { deferred } from ${JSON.stringify(core)};`);
+    for (const [name, src] of lazy) {
+      lines.push(
+        `const ${name} = deferred(() => import(${JSON.stringify(src.module)}), { strategy: ${strategyLiteral(src.loading)}, export: ${JSON.stringify(src.export)} });`
+      );
+    }
+  }
+  for (const [key, name] of hoisted) {
+    lines.push(`const ${name} = ${JSON.stringify(key.startsWith("svg:") ? key.slice(4) : key)};`);
+  }
+  if (needs.delegatedEvents.size > 0) {
+    lines.push(`delegateEvents(${JSON.stringify([...needs.delegatedEvents])});`);
+  }
+  return lines.length > 0 ? lines.join("\n") + "\n" : null;
+}
+export {
+  explainBail,
+  moduleBindings,
+  planPropsDestructure,
+  shapeOf,
+  transformProps,
+  transformTemplates
+};