@firsthandjs/compiler 0.9.0 → 0.10.0

package/dist/chunk-JEIWCE46.js

@@ -0,0 +1,1998 @@
+// packages/compiler/src/ids.ts
+import { createHash } from "node:crypto";
+function stableId(packageName, filename) {
+  const normalised = filename.split(String.fromCharCode(92)).join("/").replace(/^(?:.*\/)?(?:src|lib)\//, "");
+  return createHash("sha256").update(`${packageName}:${normalised}`).digest("hex").slice(0, 8);
+}
+
+// packages/compiler/src/plugin.ts
+import * as t16 from "@babel/types";
+
+// packages/compiler/src/components.ts
+import * as t7 from "@babel/types";
+
+// packages/compiler/src/nodes.ts
+import * as t2 from "@babel/types";
+
+// packages/compiler/src/html.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var BOOLEAN_PROPERTIES = /* @__PURE__ */ new Set([
+  "checked",
+  "disabled",
+  "multiple",
+  "muted",
+  "readOnly",
+  "selected",
+  "autofocus",
+  "autoplay",
+  "controls",
+  "loop",
+  "open",
+  "required"
+]);
+var DOM_PROPERTIES = /* @__PURE__ */ new Set([
+  "value",
+  "textContent",
+  "innerHTML",
+  "innerText",
+  "scrollTop",
+  "scrollLeft",
+  "volume",
+  "currentTime",
+  "playbackRate",
+  "srcObject"
+]);
+var SVG_ELEMENTS = /* @__PURE__ */ new Set([
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "line",
+  "polyline",
+  "polygon",
+  "ellipse",
+  "g",
+  "defs",
+  "use",
+  "text",
+  "tspan",
+  "symbol",
+  "mask",
+  "pattern",
+  "clipPath",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "filter"
+]);
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+}
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function eventName(attribute) {
+  return attribute.slice(2).toLowerCase();
+}
+function isEventName(name) {
+  return name.startsWith("on") && name.length > 2 && /[A-Z:]/.test(name[2]);
+}
+
+// packages/compiler/src/marks.ts
+import * as t from "@babel/types";
+var CHILD_THUNK = /* @__PURE__ */ Symbol("firsthand.childThunk");
+var GENERATED = /* @__PURE__ */ Symbol("firsthand.generated");
+function generated(arrow) {
+  arrow[GENERATED] = true;
+  return arrow;
+}
+var LIST_CALL = /* @__PURE__ */ Symbol("firsthand.list");
+function isKeyedList(node) {
+  return t.isCallExpression(node) && LIST_CALL in node;
+}
+
+// packages/compiler/src/nodes.ts
+var CORE = "@firsthandjs/core";
+function isComponentTag(node) {
+  const name = node.openingElement.name;
+  if (t2.isJSXMemberExpression(name)) {
+    return true;
+  }
+  if (!t2.isJSXIdentifier(name)) {
+    return false;
+  }
+  return /^[A-Z]/.test(name.name);
+}
+function tagExpression(name) {
+  if (t2.isJSXIdentifier(name)) {
+    return t2.identifier(name.name);
+  }
+  return t2.memberExpression(tagExpression(name.object), t2.identifier(name.property.name));
+}
+function isPure(node) {
+  if (PURE_LEAVES.has(node.type)) {
+    return true;
+  }
+  const parts = PURE_PARTS.get(node.type)?.(node);
+  if (parts == null) {
+    return false;
+  }
+  return parts.every((part) => part == null || t2.isExpression(part) && isPure(part));
+}
+var PURE_LEAVES = /* @__PURE__ */ new Set([
+  "Identifier",
+  "ThisExpression",
+  "StringLiteral",
+  "NumericLiteral",
+  "BooleanLiteral",
+  "NullLiteral",
+  "BigIntLiteral",
+  "RegExpLiteral"
+]);
+var PURE_PARTS = /* @__PURE__ */ new Map([
+  ["MemberExpression", memberParts],
+  ["OptionalMemberExpression", memberParts],
+  ["UnaryExpression", unaryParts],
+  [
+    "BinaryExpression",
+    (node) => [node.left, node.right]
+  ],
+  [
+    "LogicalExpression",
+    (node) => [node.left, node.right]
+  ],
+  [
+    "ConditionalExpression",
+    (node) => {
+      const conditional = node;
+      return [conditional.test, conditional.consequent, conditional.alternate];
+    }
+  ],
+  ["TemplateLiteral", (node) => node.expressions],
+  ["ArrayExpression", (node) => node.elements],
+  ["ObjectExpression", objectParts]
+]);
+function memberParts(node) {
+  const member = node;
+  return member.computed ? [member.object, member.property] : [member.object];
+}
+function unaryParts(node) {
+  const unary = node;
+  return unary.operator === "delete" ? null : [unary.argument];
+}
+function objectParts(node) {
+  const values = [];
+  for (const property of node.properties) {
+    if (!t2.isObjectProperty(property) || property.computed) {
+      return null;
+    }
+    values.push(property.value);
+  }
+  return values;
+}
+function propertyKey(name) {
+  return t2.isValidIdentifier(name) ? t2.identifier(name) : t2.stringLiteral(name);
+}
+function attributeName(attribute) {
+  const name = attribute.name;
+  return t2.isJSXNamespacedName(name) ? `${name.namespace.name}:${name.name.name}` : name.name;
+}
+function attributeValue(attribute) {
+  const value = attribute.value;
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (t2.isStringLiteral(value)) {
+    return value;
+  }
+  if (t2.isJSXExpressionContainer(value)) {
+    return value.expression;
+  }
+  throw new Error("An element is not a valid attribute value. Wrap it in braces: attr={<El />}.");
+}
+function isStaticValue(value) {
+  return t2.isStringLiteral(value) || t2.isNumericLiteral(value) || t2.isBooleanLiteral(value) || t2.isNullLiteral(value);
+}
+function canInlineAttribute(name) {
+  return !name.startsWith("prop:") && !name.startsWith("attr:") && !DOM_PROPERTIES.has(name) && !BOOLEAN_PROPERTIES.has(name);
+}
+function isFirsthandImport(binding) {
+  const parent = binding.path.parentPath;
+  if (!parent.isImportDeclaration()) {
+    return false;
+  }
+  const source = parent.node.source.value;
+  return source === CORE || source.startsWith("@firsthandjs/") || source === "firsthand";
+}
+function declaredName(path) {
+  const parent = path.parentPath;
+  if (parent.isVariableDeclarator() && t2.isIdentifier(parent.node.id)) {
+    return parent.node.id.name;
+  }
+  return "Component";
+}
+function planChildren(children) {
+  const entries = [];
+  let pending = "";
+  const flush = () => {
+    if (pending !== "") {
+      entries.push({ kind: "text", text: pending });
+      pending = "";
+    }
+  };
+  for (const child of children) {
+    if (t2.isJSXText(child)) {
+      pending += cleanText(child.value);
+      continue;
+    }
+    if (t2.isJSXExpressionContainer(child)) {
+      const expression = child.expression;
+      if (t2.isJSXEmptyExpression(expression)) {
+        continue;
+      }
+      if (t2.isStringLiteral(expression) || t2.isNumericLiteral(expression)) {
+        pending += String(expression.value);
+        continue;
+      }
+      flush();
+      const isList = expression[LIST_CALL] === true;
+      entries.push({ kind: isList ? "list" : "dynamic", expression });
+      continue;
+    }
+    flush();
+    if (t2.isJSXElement(child) && !isComponentTag(child)) {
+      entries.push({ kind: "element", element: child });
+      continue;
+    }
+    entries.push({ kind: "dynamic", expression: child });
+  }
+  flush();
+  return entries;
+}
+function cleanText(value) {
+  const lines = value.split(/\r\n|\n|\r/);
+  const kept = [];
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    if (i > 0) {
+      line = line.replace(/^[\t ]+/, "");
+    }
+    if (i < lines.length - 1) {
+      line = line.replace(/[\t ]+$/, "");
+    }
+    if (line !== "") {
+      kept.push(line);
+    }
+  }
+  return kept.join(" ");
+}
+function staticLiteral(value) {
+  if (t2.isStringLiteral(value)) {
+    return value.value;
+  }
+  if (t2.isNumericLiteral(value)) {
+    return String(value.value);
+  }
+  if (t2.isBooleanLiteral(value)) {
+    return value.value ? "" : null;
+  }
+  return null;
+}
+
+// packages/compiler/src/props.ts
+import * as t5 from "@babel/types";
+
+// packages/compiler/src/positions.ts
+import * as t3 from "@babel/types";
+function thunk(expression) {
+  const arrow = t3.arrowFunctionExpression([], expression);
+  arrow[CHILD_THUNK] = true;
+  takePosition(arrow, expression);
+  return arrow;
+}
+function takePosition(target, expression) {
+  const loc = expression.loc;
+  if (loc !== null && loc !== void 0) {
+    target.loc = { ...loc, end: loc.start };
+    expression.loc = null;
+  }
+}
+function expressionStatement2(expression) {
+  return located(t3.expressionStatement(expression), expression);
+}
+function located(node, source) {
+  if (source == null || source.loc == null) {
+    return node;
+  }
+  node.loc = source.loc;
+  return node;
+}
+
+// packages/compiler/src/state.ts
+import * as t4 from "@babel/types";
+var RUNTIME = "@firsthandjs/dom/internal";
+var SERVER_RUNTIME = "@firsthandjs/server/internal";
+function pushOnce(build, statement) {
+  build.once.push(statement);
+}
+function pushEach(build, statement) {
+  build.each.push(statement);
+}
+function runtime(state, name, source) {
+  return runtimeFrom(state, name, source ?? (state.firsthand.ssr ? SERVER_RUNTIME : RUNTIME));
+}
+function runtimeFrom(state, name, source) {
+  const key = `${source}#${name}`;
+  let local = state.firsthand.imports.get(key);
+  if (local === void 0) {
+    local = t4.identifier(`_$${name}`);
+    state.firsthand.imports.set(key, local);
+  }
+  return t4.cloneNode(local);
+}
+
+// packages/compiler/src/props.ts
+function rewritePropsDestructuring(call, name, state) {
+  const setup = call.get("arguments.0");
+  const params = setup.get("params");
+  const param = params[0];
+  if (param === void 0 || param.isIdentifier()) {
+    return;
+  }
+  if (!param.isObjectPattern()) {
+    throw call.buildCodeFrameError(
+      `${name}: a component's props parameter must be an object pattern or a plain identifier. Props are an object, so an array pattern cannot destructure them.`
+    );
+  }
+  const propsId = setup.scope.generateUidIdentifier("props");
+  const collected = { reads: [], rests: [], call, name };
+  collectPattern(param.node, t5.cloneNode(propsId), collected);
+  setup.scope.crawl();
+  const references = referencesOf(setup, propsId, collected);
+  param.replaceWith(propsId);
+  for (const entry of references) {
+    for (const reference2 of entry.paths) {
+      if (entry.access !== propsId) {
+        reference2.replaceWith(located(t5.cloneNode(entry.access), reference2.node));
+      }
+    }
+  }
+  hoistRests(setup, propsId, collected.rests, state);
+}
+function referencesOf(setup, propsId, collected) {
+  const { call, name } = collected;
+  const references = [];
+  for (const entry of [...collected.reads, ...collected.rests]) {
+    const access = "access" in entry ? entry.access : propsId;
+    const binding = setup.scope.getBinding(entry.local);
+    if (binding.constantViolations.length > 0) {
+      throw call.buildCodeFrameError(
+        `${name}: \`${entry.local}\` is destructured from props and then assigned to. Props are readonly; assign to a signal instead.`
+      );
+    }
+    references.push({ paths: binding.referencePaths, access });
+  }
+  return references;
+}
+function hoistRests(setup, propsId, rests, state) {
+  if (rests.length === 0) {
+    return;
+  }
+  if (!setup.get("body").isBlockStatement()) {
+    const body = setup.node.body;
+    setup.node.body = t5.blockStatement([t5.returnStatement(body)]);
+  }
+  const block = setup.get("body");
+  for (const rest of rests) {
+    block.node.body.unshift(
+      t5.variableDeclaration("const", [
+        t5.variableDeclarator(
+          t5.identifier(rest.local),
+          t5.callExpression(runtime(state, "rest"), [
+            t5.cloneNode(propsId),
+            t5.arrayExpression(rest.omit.map((key) => t5.stringLiteral(key)))
+          ])
+        )
+      ])
+    );
+  }
+}
+function collectPattern(pattern, base, into) {
+  const { reads, rests, call, name } = into;
+  const seen = [];
+  for (const property of pattern.properties) {
+    if (t5.isRestElement(property)) {
+      rests.push({ local: property.argument.name, omit: [...seen] });
+      continue;
+    }
+    if (property.computed || !t5.isIdentifier(property.key)) {
+      throw call.buildCodeFrameError(
+        `${name}: props can only be destructured by plain key. A computed key would have to be resolved at setup time, which is exactly the snapshot this rewrite avoids.`
+      );
+    }
+    seen.push(property.key.name);
+    const access = t5.memberExpression(
+      t5.cloneNode(base),
+      t5.identifier(property.key.name)
+    );
+    const value = property.value;
+    if (t5.isIdentifier(value)) {
+      reads.push({ local: value.name, access });
+    } else if (t5.isAssignmentPattern(value) && t5.isIdentifier(value.left)) {
+      reads.push({
+        local: value.left.name,
+        access: t5.logicalExpression("??", access, value.right)
+      });
+    } else if (t5.isObjectPattern(value)) {
+      collectPattern(value, access, into);
+    } else {
+      throw call.buildCodeFrameError(
+        `${name}: this destructuring pattern cannot be rewritten into live reads. Take the props object and read from it where you need the value.`
+      );
+    }
+  }
+}
+
+// packages/compiler/src/strict.ts
+import * as t6 from "@babel/types";
+function checkKeptReads(setup, name) {
+  const parameter = setup.node.params[0];
+  const propsName = t6.isIdentifier(parameter) ? parameter.name : null;
+  const body = setup.get("body");
+  if (!body.isBlockStatement()) {
+    return;
+  }
+  body.traverse({
+    Function(nested) {
+      nested.skip();
+    },
+    VariableDeclarator(declarator) {
+      const init = declarator.node.init;
+      if (init === null || init === void 0 || !readsOnly(init, propsName)) {
+        return;
+      }
+      const target = declarator.node.id;
+      const label = t6.isIdentifier(target) ? `\`${target.name}\`` : "This value";
+      throw declarator.buildCodeFrameError(
+        `${name}: ${label} is read once, here, and then kept. A setup runs one time per instance, so this value will not change again.
+
+Move the read into the part, handler, effect or computed that should re-read it \u2014 or wrap it in snapshot(() => \u2026) if reading once is what you meant.`
+      );
+    }
+  });
+}
+function checkDecidedOnce(setup, name) {
+  const body = setup.get("body");
+  if (!body.isBlockStatement()) {
+    checkChoice(setup.node.body, body, name);
+    return;
+  }
+  body.traverse({
+    Function(nested) {
+      nested.skip();
+    },
+    ReturnStatement(statement) {
+      const returned = statement.node.argument;
+      if (returned !== null && returned !== void 0) {
+        checkChoice(returned, statement, name);
+      }
+    },
+    /**
+     * The same mistake spelled with a keyword, and the one that actually
+     * shipped: a route guard that returned `<Navigate />` early left the page
+     * it was meant to hide on the screen after a sign-out.
+     */
+    IfStatement(statement) {
+      if (!readsSignal(statement.node.test)) {
+        return;
+      }
+      if (returnsView(statement.node.consequent) || returnsView(statement.node.alternate)) {
+        reportDecidedOnce(statement.get("test"), name);
+      }
+    }
+  });
+}
+function checkChoice(returned, at, name) {
+  if (t6.isConditionalExpression(returned)) {
+    if (!hasView(returned.consequent) && !hasView(returned.alternate)) {
+      return;
+    }
+    if (readsSignal(returned.test)) {
+      reportDecidedOnce(at, name);
+    }
+    return;
+  }
+  if (t6.isLogicalExpression(returned) && returned.operator !== "??") {
+    if (!hasView(returned.right) && !hasView(returned.left)) {
+      return;
+    }
+    if (readsSignal(returned.left)) {
+      reportDecidedOnce(at, name);
+    }
+  }
+}
+function reportDecidedOnce(at, name) {
+  throw at.buildCodeFrameError(
+    `${name}: this view is chosen once, here, from a value that changes. A setup runs one time per instance, so the other branch will never appear.
+
+Either put the choice inside the markup, where it is a part:
+
+  return <>{open.value ? <A /> : <B />}</>;
+
+or return a render function, which is a reactive scope of its own and may use ordinary control flow:
+
+  return () => (open.value ? <A /> : <B />);`
+  );
+}
+function checkRunBody(setup, name) {
+  const runs = [];
+  const body = setup.get("body");
+  body.traverse({
+    Function(nested) {
+      nested.skip();
+    },
+    ReturnStatement(statement) {
+      const argument = statement.get("argument");
+      if (argument.isArrowFunctionExpression() || argument.isFunctionExpression()) {
+        runs.push(argument);
+      }
+    }
+  });
+  for (const run of runs) {
+    checkNothingPersistent(run, name);
+    checkRepeatedMarkup(run, name);
+  }
+}
+var PERSISTENT = /* @__PURE__ */ new Map([
+  ["signal", "a signal"],
+  ["computed", "a computed"],
+  ["effect", "an effect"],
+  ["deepSignal", "a deep signal"],
+  ["useResource", "a resource"],
+  ["useAction", "an action"],
+  ["onCleanup", "a cleanup"],
+  ["provide", "a context value"]
+]);
+function checkNothingPersistent(run, name) {
+  run.traverse({
+    Function(nested) {
+      nested.skip();
+    },
+    CallExpression(call) {
+      const callee = call.node.callee;
+      if (!t6.isIdentifier(callee)) {
+        return;
+      }
+      const what = PERSISTENT.get(callee.name);
+      if (what === void 0) {
+        return;
+      }
+      const binding = call.scope.getBinding(callee.name);
+      if (binding === void 0 || !isFirsthandImport(binding)) {
+        return;
+      }
+      throw call.buildCodeFrameError(
+        `${name}: this render function makes ${what}, and it runs again whenever something it read changes \u2014 so this would be made again, and the one before it thrown away.
+
+Move it into the setup, above the render function. Persistent things are made once, where the setup runs once.`
+      );
+    }
+  });
+}
+function checkRepeatedMarkup(run, name) {
+  const report = (at) => {
+    throw at.buildCodeFrameError(
+      `${name}: this markup is written once and appears many times, so where it stands cannot say which of them is which.
+
+Give it a key:
+
+  {rows.map((row) => <Row key={row.id} row={row} />)}`
+    );
+  };
+  run.traverse({
+    Function(nested) {
+      nested.skip();
+    },
+    "ForStatement|ForOfStatement|ForInStatement|WhileStatement|DoWhileStatement"(loop) {
+      loop.traverse({
+        JSXElement(element) {
+          element.skip();
+          if (!hasKey(element.node)) {
+            report(element);
+          }
+        }
+      });
+    },
+    CallExpression(call) {
+      const callee = call.node.callee;
+      if (LIST_CALL in call.node || !t6.isMemberExpression(callee) || callee.computed || !t6.isIdentifier(callee.property, { name: "map" })) {
+        return;
+      }
+      call.traverse({
+        JSXElement(element) {
+          element.skip();
+          if (!hasKey(element.node)) {
+            report(element);
+          }
+        }
+      });
+    }
+  });
+}
+function hasKey(element) {
+  return element.openingElement.attributes.some(
+    (attribute) => t6.isJSXAttribute(attribute) && attributeName(attribute) === "key"
+  );
+}
+function returnsView(node) {
+  if (node === null || node === void 0) {
+    return false;
+  }
+  if (t6.isReturnStatement(node)) {
+    return node.argument !== null && node.argument !== void 0 && hasView(node.argument);
+  }
+  if (t6.isBlockStatement(node)) {
+    return node.body.some((inner) => returnsView(inner));
+  }
+  return false;
+}
+function hasView(node) {
+  if (t6.isConditionalExpression(node)) {
+    return hasView(node.consequent) || hasView(node.alternate);
+  }
+  return t6.isJSXElement(node) || t6.isJSXFragment(node);
+}
+function readsSignal(node) {
+  let found = false;
+  const walk = (current) => {
+    if (current === null || current === void 0 || found) {
+      return;
+    }
+    if (t6.isMemberExpression(current)) {
+      if (!current.computed && t6.isIdentifier(current.property, { name: "value" })) {
+        found = true;
+        return;
+      }
+      walk(current.object);
+      return;
+    }
+    if (t6.isUnaryExpression(current)) {
+      walk(current.argument);
+      return;
+    }
+    if (t6.isBinaryExpression(current) || t6.isLogicalExpression(current)) {
+      walk(current.left);
+      walk(current.right);
+      return;
+    }
+    if (t6.isConditionalExpression(current)) {
+      walk(current.test);
+    }
+  };
+  walk(node);
+  return found;
+}
+function readsOnly(node, propsName) {
+  const found = { read: false };
+  return walkRead(node, propsName, found) && found.read;
+}
+function walkRead(current, propsName, found) {
+  if (t6.isTemplateLiteral(current)) {
+    return current.expressions.every((part) => walkRead(part, propsName, found));
+  }
+  if (t6.isIdentifier(current) || t6.isLiteral(current)) {
+    return true;
+  }
+  if (t6.isMemberExpression(current)) {
+    return walkMember(current, propsName, found);
+  }
+  if (t6.isUnaryExpression(current)) {
+    return walkRead(current.argument, propsName, found);
+  }
+  if (t6.isBinaryExpression(current) || t6.isLogicalExpression(current)) {
+    return walkRead(current.left, propsName, found) && walkRead(current.right, propsName, found);
+  }
+  if (t6.isConditionalExpression(current)) {
+    return walkRead(current.test, propsName, found) && walkRead(current.consequent, propsName, found) && walkRead(current.alternate, propsName, found);
+  }
+  return false;
+}
+function walkMember(current, propsName, found) {
+  const property = current.property;
+  if (!current.computed && t6.isIdentifier(property, { name: "value" })) {
+    found.read = true;
+  }
+  if (propsName !== null && t6.isIdentifier(current.object, { name: propsName })) {
+    found.read = true;
+  }
+  return walkRead(current.object, propsName, found) && (!current.computed || walkRead(property, propsName, found));
+}
+
+// packages/compiler/src/components.ts
+function annotateComponent(path, state, options) {
+  const callee = path.node.callee;
+  if (!t7.isIdentifier(callee, { name: "component" }) || path.node.arguments.length > 2) {
+    return;
+  }
+  const binding = path.scope.getBinding("component");
+  if (binding === void 0 || !isFirsthandImport(binding)) {
+    return;
+  }
+  const setup = path.node.arguments[0];
+  if (!t7.isArrowFunctionExpression(setup) && !t7.isFunctionExpression(setup)) {
+    return;
+  }
+  const name = declaredName(path);
+  rewritePropsDestructuring(path, name, state);
+  if (options.strictReactivity !== false) {
+    const setupPath = path.get("arguments.0");
+    checkKeptReads(setupPath, name);
+    checkDecidedOnce(setupPath, name);
+    checkRunBody(setupPath, name);
+  }
+  path.node.arguments = [
+    setup,
+    path.node.arguments[1] ?? t7.identifier("undefined"),
+    t7.stringLiteral(`${state.firsthand.moduleId}/${name}`),
+    t7.stringLiteral(name)
+  ];
+}
+var NAMED = /* @__PURE__ */ new Map([
+  ["signal", "signal"],
+  ["computed", "computed"],
+  ["deepSignal", "signal"]
+]);
+function nameCell(path, state) {
+  const init = path.node.init;
+  const target = path.node.id;
+  if (!t7.isCallExpression(init) || !t7.isIdentifier(target) || !t7.isIdentifier(init.callee)) {
+    return;
+  }
+  const kind = NAMED.get(init.callee.name);
+  if (kind === void 0) {
+    return;
+  }
+  const binding = path.scope.getBinding(init.callee.name);
+  if (binding === void 0 || !isFirsthandImport(binding)) {
+    return;
+  }
+  const line = init.loc.start.line;
+  const source = state.filename;
+  const cut = Math.max(source.lastIndexOf("/"), source.lastIndexOf(String.fromCharCode(92)));
+  const where = `${source.slice(cut + 1)}:${String(line)}`;
+  const call = t7.callExpression(runtime(state, "label"), [
+    init,
+    t7.stringLiteral(kind),
+    t7.stringLiteral(`${target.name} (${where})`)
+  ]);
+  path.node.init = call;
+}
+
+// packages/compiler/src/jsx.ts
+import * as t14 from "@babel/types";
+
+// packages/compiler/src/markup.ts
+import * as t8 from "@babel/types";
+function pushText(markup, text) {
+  markup.parts[markup.parts.length - 1] = markup.parts[markup.parts.length - 1] + text;
+}
+function pushHole(markup, value) {
+  markup.values.push(value);
+  markup.parts.push("");
+}
+function compileMarkup(path, state) {
+  const markup = { parts: [""], values: [] };
+  emitMarkupElement(path.node, markup, state);
+  if (markup.values.length === 0) {
+    return t8.callExpression(runtime(state, "ssr"), [
+      t8.arrayExpression([t8.stringLiteral(markup.parts[0])])
+    ]);
+  }
+  return t8.callExpression(runtime(state, "ssr"), [
+    t8.arrayExpression(markup.parts.map((part) => t8.stringLiteral(part))),
+    ...markup.values
+  ]);
+}
+function emitMarkupElement(node, markup, state) {
+  const name = node.openingElement.name;
+  if (!t8.isJSXIdentifier(name)) {
+    const namespaced = name;
+    throw new Error(
+      `Namespaced element names are not supported: <${namespaced.namespace.name}:${namespaced.name.name}>. Write the element without a namespace; SVG children are resolved by the parser.`
+    );
+  }
+  const tag = name.name;
+  pushText(markup, `<${tag}`);
+  for (const attribute of node.openingElement.attributes) {
+    emitMarkupAttribute(attribute, markup, state);
+  }
+  pushText(markup, ">");
+  emitMarkupChildren(node.children, markup, state);
+  if (!VOID_ELEMENTS.has(tag)) {
+    pushText(markup, `</${tag}>`);
+  }
+}
+function emitMarkupAttribute(attribute, markup, state) {
+  if (t8.isJSXSpreadAttribute(attribute)) {
+    pushHole(markup, t8.callExpression(runtime(state, "spread"), [attribute.argument]));
+    return;
+  }
+  const name = attributeName(attribute);
+  const value = attributeValue(attribute);
+  if (name === "ref" || isEventName(name)) {
+    return;
+  }
+  if (name === "key") {
+    return;
+  }
+  if (value === null) {
+    pushText(markup, ` ${name}=""`);
+    return;
+  }
+  if (isStaticValue(value)) {
+    const literal = staticLiteral(value);
+    if (literal !== null) {
+      pushText(markup, ` ${name}="${escapeAttribute(literal)}"`);
+    }
+    return;
+  }
+  pushHole(markup, markupAttributeCall(name, value, state));
+}
+function markupAttributeCall(name, value, state) {
+  if (name.startsWith("prop:")) {
+    return t8.callExpression(runtime(state, "setProperty"), [t8.stringLiteral(name.slice(5)), value]);
+  }
+  if (name.startsWith("attr:")) {
+    return t8.callExpression(runtime(state, "setAttribute"), [
+      t8.stringLiteral(name.slice(5)),
+      value
+    ]);
+  }
+  if (name === "class" || name === "className") {
+    return t8.callExpression(runtime(state, "setClass"), [value]);
+  }
+  if (name === "style") {
+    return t8.callExpression(runtime(state, "setStyle"), [value]);
+  }
+  if (BOOLEAN_PROPERTIES.has(name)) {
+    return t8.callExpression(runtime(state, "setBoolean"), [t8.stringLiteral(name), value]);
+  }
+  if (DOM_PROPERTIES.has(name)) {
+    return t8.callExpression(runtime(state, "setProperty"), [t8.stringLiteral(name), value]);
+  }
+  return t8.callExpression(runtime(state, "setAttribute"), [t8.stringLiteral(name), value]);
+}
+function emitMarkupChildren(children, markup, state) {
+  const entries = planChildren(children);
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (entry.kind === "text") {
+      pushText(markup, escapeText(entry.text));
+      continue;
+    }
+    if (entry.kind === "element") {
+      emitMarkupElement(entry.element, markup, state);
+      continue;
+    }
+    if (entries.length > 1) {
+      pushText(markup, "<!--[-->");
+    }
+    pushHole(markup, t8.callExpression(runtime(state, "child"), [entry.expression]));
+    if (i !== entries.length - 1) {
+      pushText(markup, "<!---->");
+    }
+  }
+}
+
+// packages/compiler/src/runs.ts
+import * as t9 from "@babel/types";
+function collectViews(program, state) {
+  const { views, viewNodes } = state.firsthand;
+  const record = (path) => {
+    let fn = path.getFunctionParent();
+    while (fn !== null) {
+      viewNodes.add(fn.node);
+      const named = moduleLevelName(fn);
+      if (named !== null) {
+        views.set(named, t9.identifier(named));
+      }
+      fn = fn.getFunctionParent();
+    }
+  };
+  program.traverse({
+    JSXElement: record,
+    JSXFragment: record
+  });
+}
+function moduleLevelName(fn) {
+  if (fn.isFunctionDeclaration()) {
+    const id = fn.node.id;
+    if (id === null || id === void 0) {
+      return null;
+    }
+    return t9.isProgram(fn.parentPath.scope.block) ? id.name : null;
+  }
+  const declarator = fn.parentPath;
+  if (!declarator.isVariableDeclarator() || !t9.isIdentifier(declarator.node.id)) {
+    return null;
+  }
+  return t9.isProgram(declarator.scope.block) ? declarator.node.id.name : null;
+}
+function isLocalView(path, state) {
+  const name = path.node.openingElement.name;
+  if (!t9.isJSXIdentifier(name)) {
+    return false;
+  }
+  const binding = path.scope.getBinding(name.name);
+  if (binding === void 0 || binding.kind === "module" || binding.constantViolations.length > 0) {
+    return false;
+  }
+  if (binding.path.isFunctionDeclaration()) {
+    return state.firsthand.viewNodes.has(binding.path.node);
+  }
+  if (!binding.path.isVariableDeclarator()) {
+    return false;
+  }
+  const init = binding.path.node.init;
+  if (!t9.isArrowFunctionExpression(init) && !t9.isFunctionExpression(init)) {
+    return false;
+  }
+  return state.firsthand.viewNodes.has(init);
+}
+function collectRuns(program, state) {
+  program.traverse({
+    CallExpression(call) {
+      giveStores(call, state);
+    }
+  });
+}
+function giveStores(call, state) {
+  if (!isComponentCall(call)) {
+    return;
+  }
+  const setup = call.get("arguments.0");
+  if (!setup.isArrowFunctionExpression() && !setup.isFunctionExpression()) {
+    return;
+  }
+  const found = returnedFunctions(setup);
+  if (found.length === 0) {
+    return;
+  }
+  setup.ensureBlock();
+  const block = setup.get("body");
+  for (const run of found) {
+    const store = setup.scope.generateUidIdentifier("store");
+    block.unshiftContainer(
+      "body",
+      t9.variableDeclaration("const", [
+        t9.variableDeclarator(
+          store,
+          t9.callExpression(runtime(state, "store"), [t9.stringLiteral(declaredName(call))])
+        )
+      ])
+    );
+    let index = 0;
+    state.firsthand.runs.set(run.node, { node: run.node, store, next: () => index++ });
+    closeRun(run, store, state);
+  }
+}
+function returnedFunctions(setup) {
+  const found = [];
+  const body = setup.get("body");
+  if (!body.isBlockStatement()) {
+    if (body.isArrowFunctionExpression() || body.isFunctionExpression()) {
+      found.push(body);
+    }
+    return found;
+  }
+  body.traverse({
+    // A handler or a callback returns its own things; only what the setup
+    // itself hands back is the view.
+    Function(nested) {
+      nested.skip();
+    },
+    ReturnStatement(statement) {
+      const argument = statement.get("argument");
+      if (argument.isArrowFunctionExpression() || argument.isFunctionExpression()) {
+        found.push(argument);
+      }
+    }
+  });
+  return found;
+}
+function closeRun(run, store, state) {
+  const body = run.get("body");
+  if (!body.isBlockStatement()) {
+    body.replaceWith(
+      t9.callExpression(runtime(state, "ran"), [t9.cloneNode(store), body.node])
+    );
+    return;
+  }
+  const returns = [];
+  body.traverse({
+    Function(nested) {
+      nested.skip();
+    },
+    ReturnStatement(statement) {
+      returns.push(statement);
+    }
+  });
+  for (const statement of returns) {
+    statement.node.argument = t9.callExpression(runtime(state, "ran"), [
+      t9.cloneNode(store),
+      statement.node.argument ?? t9.identifier("undefined")
+    ]);
+  }
+}
+function isComponentCall(path) {
+  if (!t9.isIdentifier(path.node.callee, { name: "component" })) {
+    return false;
+  }
+  const binding = path.scope.getBinding("component");
+  return binding !== void 0 && isFirsthandImport(binding);
+}
+function enclosingRun(path, state) {
+  let fn = path.getFunctionParent();
+  while (fn !== null && GENERATED in fn.node) {
+    fn = fn.getFunctionParent();
+  }
+  if (fn === null) {
+    return null;
+  }
+  return state.firsthand.runs.get(fn.node) ?? null;
+}
+function dependsOnRun(node, run, at) {
+  if (run === null) {
+    return false;
+  }
+  const names = /* @__PURE__ */ new Set();
+  collectNames(node, names);
+  for (const name of names) {
+    const binding = at.scope.getBinding(name);
+    if (binding === void 0) {
+      continue;
+    }
+    if (binding.scope.block === run.node || binding.path.findParent((parent) => parent.node === run.node) !== null) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectNames(node, into) {
+  if (t9.isIdentifier(node)) {
+    into.add(node.name);
+    return;
+  }
+  for (const key of t9.VISITOR_KEYS[node.type]) {
+    if (isSpelling(node, key)) {
+      continue;
+    }
+    const value = node[key];
+    for (const child of Array.isArray(value) ? value : [value]) {
+      if (typeof child === "object" && child !== null) {
+        collectNames(child, into);
+      }
+    }
+  }
+}
+function isSpelling(node, key) {
+  if (t9.isMemberExpression(node)) {
+    return !node.computed && key === "property";
+  }
+  if (t9.isObjectProperty(node) || t9.isObjectMethod(node)) {
+    return !node.computed && key === "key";
+  }
+  return false;
+}
+function canRetain(node, build) {
+  for (const attribute of node.openingElement.attributes) {
+    if (madeOncePerRun(attribute, build)) {
+      return false;
+    }
+  }
+  for (const child of node.children) {
+    if (t9.isJSXElement(child)) {
+      if (!isComponentTag(child) && !canRetain(child, build)) {
+        return false;
+      }
+      continue;
+    }
+    if (t9.isJSXExpressionContainer(child) && !t9.isJSXEmptyExpression(child.expression) && isKeyedList(child.expression) && listHoldsRunValue(child.expression, build)) {
+      return false;
+    }
+  }
+  return true;
+}
+function listHoldsRunValue(call, build) {
+  return call.arguments.slice(1).some((argument) => dependsOnRun(argument, build.run, build.at));
+}
+function madeOncePerRun(attribute, build) {
+  if (t9.isJSXSpreadAttribute(attribute)) {
+    return dependsOnRun(attribute.argument, build.run, build.at);
+  }
+  const value = attribute.value;
+  return attributeName(attribute) === "ref" && t9.isJSXExpressionContainer(value) && !t9.isJSXEmptyExpression(value.expression) && dependsOnRun(value.expression, build.run, build.at);
+}
+
+// packages/compiler/src/site.ts
+import * as t13 from "@babel/types";
+
+// packages/compiler/src/template.ts
+import * as t12 from "@babel/types";
+
+// packages/compiler/src/attributes.ts
+import * as t11 from "@babel/types";
+
+// packages/compiler/src/guarded.ts
+import * as t10 from "@babel/types";
+function guardedWrite(build, state, value, write) {
+  const run = build.run;
+  const slot = build.name("_w$");
+  const held = build.name("_x$");
+  const last = () => t10.memberExpression(t10.cloneNode(slot), t10.identifier("last"));
+  pushEach(
+    build,
+    t10.variableDeclaration("const", [
+      t10.variableDeclarator(
+        slot,
+        t10.callExpression(runtime(state, "site"), [
+          t10.cloneNode(run.store),
+          t10.numericLiteral(run.next())
+        ])
+      ),
+      t10.variableDeclarator(held, value)
+    ])
+  );
+  pushEach(
+    build,
+    t10.ifStatement(
+      t10.binaryExpression("!==", last(), t10.cloneNode(held)),
+      t10.blockStatement([
+        expressionStatement2(t10.assignmentExpression("=", last(), t10.cloneNode(held))),
+        expressionStatement2(t10.callExpression(runtime(state, "wrote"), [t10.cloneNode(run.store)])),
+        expressionStatement2(write(t10.cloneNode(held)))
+      ])
+    )
+  );
+}
+
+// packages/compiler/src/attributes.ts
+function emitAttribute(attribute, host) {
+  if (t11.isJSXSpreadAttribute(attribute)) {
+    host.deferred.push(() => {
+      emitSpread(attribute.argument, host);
+    });
+    return;
+  }
+  const name = attributeName(attribute);
+  const value = attributeValue(attribute);
+  if (name === "ref") {
+    host.deferred.push(() => {
+      emitRef(value, host);
+    });
+    return;
+  }
+  if (isEventName(name)) {
+    host.deferred.push(() => {
+      emitListener(name, value, host);
+    });
+    return;
+  }
+  if (value !== null && isStaticValue(value) && canInlineAttribute(name)) {
+    const literal = staticLiteral(value);
+    if (literal !== null) {
+      host.build.html.push(` ${name}="${escapeAttribute(literal)}"`);
+    }
+    return;
+  }
+  if (value === null) {
+    host.build.html.push(` ${name}=""`);
+    return;
+  }
+  host.deferred.push(() => {
+    emitDynamic(name, value, host);
+  });
+}
+function emitSpread(argument, host) {
+  const { build, self, state } = host;
+  pushOnce(
+    build,
+    expressionStatement2(
+      t11.callExpression(runtime(state, "bind"), [
+        t11.arrowFunctionExpression(
+          [],
+          t11.callExpression(runtime(state, "spread"), [t11.cloneNode(self), argument])
+        )
+      ])
+    )
+  );
+}
+function emitRef(value, host) {
+  pushOnce(host.build, expressionStatement2(t11.callExpression(value, [t11.cloneNode(host.self)])));
+}
+function emitListener(name, value, host) {
+  const { build, self, state } = host;
+  const parts = name.split(":");
+  const literal = parts[0] === "on";
+  const type = literal ? parts[1] : eventName(parts[0]);
+  const modifier = parts[literal ? 2 : 1];
+  const args = [t11.cloneNode(self), t11.stringLiteral(type), value];
+  if (modifier === "native") {
+    args.push(t11.booleanLiteral(true));
+  } else if (modifier !== void 0) {
+    args.push(
+      t11.objectExpression([t11.objectProperty(propertyKey(modifier), t11.booleanLiteral(true))])
+    );
+  }
+  const attach = expressionStatement2(t11.callExpression(runtime(state, "on"), args));
+  if (dependsOnRun(value, build.run, build.at)) {
+    pushEach(build, attach);
+  } else {
+    pushOnce(build, attach);
+  }
+}
+function emitDynamic(name, value, host) {
+  const { build, state } = host;
+  if (dependsOnRun(value, build.run, build.at)) {
+    guardedWrite(build, state, value, (held) => dynamicAttributeCall(name, held, host));
+    return;
+  }
+  pushOnce(
+    build,
+    expressionStatement2(
+      t11.callExpression(runtime(state, "bind"), [
+        located(t11.arrowFunctionExpression([], dynamicAttributeCall(name, value, host)), value)
+      ])
+    )
+  );
+}
+function dynamicAttributeCall(name, value, host) {
+  const { self, state, tag } = host;
+  const call = (runtimeName, attribute) => t11.callExpression(runtime(state, runtimeName), [
+    t11.cloneNode(self),
+    t11.stringLiteral(attribute),
+    value
+  ]);
+  if (name.startsWith("prop:")) {
+    return call("setProperty", name.slice(5));
+  }
+  if (name.startsWith("attr:")) {
+    return call("setAttribute", name.slice(5));
+  }
+  if (name === "class" || name === "className" || name === "style") {
+    return call("applyProp", name);
+  }
+  if (BOOLEAN_PROPERTIES.has(name)) {
+    return call("setBoolean", name);
+  }
+  if (DOM_PROPERTIES.has(name) && !SVG_ELEMENTS.has(tag)) {
+    return call("setProperty", name);
+  }
+  return call("setAttribute", name);
+}
+
+// packages/compiler/src/template.ts
+function emitElement(node, build, self, state) {
+  const name = node.openingElement.name;
+  if (!t12.isJSXIdentifier(name)) {
+    const namespaced = name;
+    throw new Error(
+      `Namespaced element names are not supported: <${namespaced.namespace.name}:${namespaced.name.name}>. Write the element without a namespace; SVG children are resolved by the parser.`
+    );
+  }
+  const tag = name.name;
+  build.html.push(`<${tag}`);
+  const host = { build, self, state, deferred: [], tag };
+  for (const attribute of node.openingElement.attributes) {
+    emitAttribute(attribute, host);
+  }
+  build.html.push(">");
+  for (const emit of host.deferred) {
+    emit();
+  }
+  emitChildren(node.children, host);
+  if (!VOID_ELEMENTS.has(tag)) {
+    build.html.push(`</${tag}>`);
+  }
+}
+function emitChildren(children, host) {
+  const entries = planChildren(children);
+  const cursor = { previous: null, previousIndex: 0, index: 0 };
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (entry.kind === "text") {
+      host.build.html.push(escapeText(entry.text));
+    } else if (entry.kind === "element") {
+      const element = entry.element;
+      const self = needsReference(element) ? reference(cursor, host) : t12.identifier("_unused$");
+      emitElement(element, host.build, self, host.state);
+    } else {
+      emitChildPart(entry, i === entries.length - 1, cursor, host);
+    }
+    cursor.index++;
+  }
+}
+function reference(cursor, host) {
+  const id = host.build.next();
+  host.build.statements.push(
+    t12.variableDeclaration("const", [t12.variableDeclarator(id, navigate(cursor, host))])
+  );
+  cursor.previous = id;
+  cursor.previousIndex = cursor.index;
+  return id;
+}
+function emitChildPart(entry, isLast, cursor, host) {
+  const { build, self, state } = host;
+  const expression = entry.expression;
+  let marker = null;
+  if (!isLast) {
+    build.html.push("<!>");
+    marker = t12.cloneNode(reference(cursor, host));
+  }
+  if (entry.kind !== "list" && dependsOnRun(expression, build.run, build.at)) {
+    const run = build.run;
+    pushEach(
+      build,
+      expressionStatement2(
+        t12.callExpression(runtime(state, "writeChild"), [
+          t12.cloneNode(run.store),
+          t12.numericLiteral(run.next()),
+          t12.cloneNode(self),
+          marker ?? t12.nullLiteral(),
+          expression
+        ])
+      )
+    );
+    return;
+  }
+  const args = [
+    t12.cloneNode(self),
+    // A list part is already a thunk that owns its rows; wrapping it would
+    // rebuild the whole list on every evaluation.
+    entry.kind === "list" ? listFedByRun(expression, host) : thunk(expression)
+  ];
+  if (marker !== null) {
+    args.push(marker);
+  }
+  pushOnce(build, expressionStatement2(t12.callExpression(runtime(state, "insert"), args)));
+}
+function listFedByRun(call, host) {
+  const { build, state } = host;
+  const source = call.arguments[0];
+  if (build.run === null || !t12.isExpression(source) || !dependsOnRun(source, build.run, build.at)) {
+    return call;
+  }
+  const run = build.run;
+  const holder = build.name("_data$");
+  build.statements.push(
+    t12.variableDeclaration("const", [
+      t12.variableDeclarator(
+        holder,
+        t12.callExpression(runtime(state, "cell"), [
+          t12.cloneNode(run.store),
+          t12.numericLiteral(run.next()),
+          // What the cell holds is the data itself, not a thunk over it: a
+          // list's source is a value, unlike a child, which is a reading that
+          // belongs to the part displaying it (ADR-0026).
+          //
+          // `rewriteKeyedMaps` always writes the source as `() => <data>`, so
+          // the body is the data and there is no other shape to answer for.
+          source.body
+        ])
+      )
+    ])
+  );
+  call.arguments[0] = t12.arrowFunctionExpression(
+    [],
+    t12.memberExpression(t12.cloneNode(holder), t12.identifier("value"))
+  );
+  return call;
+}
+function needsReference(element) {
+  if (element.openingElement.attributes.some(attributeNeedsReference)) {
+    return true;
+  }
+  for (const entry of planChildren(element.children)) {
+    if (entry.kind === "dynamic" || entry.kind === "list") {
+      return true;
+    }
+    if (entry.kind === "element" && needsReference(entry.element)) {
+      return true;
+    }
+  }
+  return false;
+}
+function attributeNeedsReference(attribute) {
+  if (t12.isJSXSpreadAttribute(attribute)) {
+    return true;
+  }
+  const name = attributeName(attribute);
+  if (name === "ref" || name.startsWith("on")) {
+    return true;
+  }
+  const value = attributeValue(attribute);
+  return value !== null && (!isStaticValue(value) || !canInlineAttribute(name));
+}
+function navigate(cursor, host) {
+  const { self, state } = host;
+  const hydratable = state.firsthand.hydratable;
+  const first = hydratable ? runtime(state, "first") : null;
+  const next = hydratable ? runtime(state, "next") : null;
+  let expression;
+  let steps;
+  if (cursor.previous === null) {
+    expression = hydratable ? t12.callExpression(first, [t12.cloneNode(self)]) : t12.memberExpression(t12.cloneNode(self), t12.identifier("firstChild"));
+    steps = cursor.index;
+  } else {
+    expression = t12.cloneNode(cursor.previous);
+    steps = cursor.index - cursor.previousIndex;
+  }
+  for (let i = 0; i < steps; i++) {
+    expression = hydratable ? t12.callExpression(next, [expression]) : t12.memberExpression(expression, t12.identifier("nextSibling"));
+  }
+  return expression;
+}
+
+// packages/compiler/src/site.ts
+function compileTemplate(path, state) {
+  const build = newBuild(path, state);
+  const root = t13.identifier("_el$");
+  emitElement(path.node, build, root, state);
+  const templateId = registerTemplate(build, state);
+  const body = build.run === null ? freshForm(root, templateId, build) : keptForm(root, templateId, build, state);
+  return t13.callExpression(generated(t13.arrowFunctionExpression([], t13.blockStatement(body))), []);
+}
+function newBuild(path, state) {
+  let names = 0;
+  const statements = [];
+  const build = {
+    html: [],
+    statements,
+    once: statements,
+    each: statements,
+    run: null,
+    at: path,
+    next: /* @__PURE__ */ (() => {
+      let n = 0;
+      return () => t13.identifier(`_el$${String(++n)}`);
+    })(),
+    name: (prefix) => t13.identifier(`${prefix}${String(++names)}`)
+  };
+  const run = enclosingRun(path, state);
+  if (run !== null) {
+    build.run = run;
+    if (canRetain(path.node, build)) {
+      build.once = [];
+      build.each = [];
+    } else {
+      build.run = null;
+    }
+  }
+  return build;
+}
+function registerTemplate(build, state) {
+  const templateId = t13.identifier(`_tmpl$${String(++state.firsthand.counter)}`);
+  state.firsthand.templates.push(
+    t13.variableDeclarator(
+      templateId,
+      t13.addComment(
+        t13.callExpression(runtime(state, "template"), [t13.stringLiteral(build.html.join(""))]),
+        "leading",
+        "#__PURE__"
+      )
+    )
+  );
+  return templateId;
+}
+function freshForm(root, templateId, build) {
+  return [
+    t13.variableDeclaration("const", [
+      t13.variableDeclarator(root, t13.callExpression(t13.cloneNode(templateId), []))
+    ]),
+    ...build.statements,
+    t13.returnStatement(t13.cloneNode(root))
+  ];
+}
+function keptForm(root, templateId, build, state) {
+  const kept = {
+    root,
+    templateId,
+    slot: build.name("_site$"),
+    fresh: build.name("_new$"),
+    held: build.name("_own$"),
+    owner: build.run
+  };
+  return [
+    ...keptPrologue(kept, state),
+    ...build.statements,
+    t13.ifStatement(
+      t13.cloneNode(kept.fresh),
+      t13.blockStatement([
+        ...build.once,
+        expressionStatement2(t13.callExpression(runtime(state, "close"), [t13.cloneNode(kept.held)]))
+      ])
+    ),
+    ...build.each,
+    t13.returnStatement(t13.cloneNode(kept.root))
+  ];
+}
+function keptPrologue(kept, state) {
+  const { root, slot, fresh, held, owner, templateId } = kept;
+  return [
+    t13.variableDeclaration("const", [
+      t13.variableDeclarator(
+        slot,
+        t13.callExpression(runtime(state, "site"), [
+          t13.cloneNode(owner.store),
+          t13.numericLiteral(owner.next())
+        ])
+      )
+    ]),
+    t13.variableDeclaration("let", [
+      t13.variableDeclarator(root, t13.memberExpression(t13.cloneNode(slot), t13.identifier("node")))
+    ]),
+    t13.variableDeclaration("const", [
+      t13.variableDeclarator(
+        fresh,
+        t13.binaryExpression("===", t13.cloneNode(root), t13.identifier("undefined"))
+      )
+    ]),
+    t13.variableDeclaration("let", [t13.variableDeclarator(held)]),
+    t13.ifStatement(
+      t13.cloneNode(fresh),
+      t13.blockStatement([
+        // What this site makes belongs to the instance. A run's own scope is
+        // cleared before it runs again, and a part left there would be disposed
+        // by the very next run.
+        expressionStatement2(
+          t13.assignmentExpression(
+            "=",
+            t13.cloneNode(held),
+            t13.callExpression(runtime(state, "open"), [t13.cloneNode(owner.store), t13.cloneNode(slot)])
+          )
+        ),
+        expressionStatement2(
+          t13.assignmentExpression(
+            "=",
+            t13.cloneNode(root),
+            t13.assignmentExpression(
+              "=",
+              t13.memberExpression(t13.cloneNode(slot), t13.identifier("node")),
+              t13.callExpression(t13.cloneNode(templateId), [])
+            )
+          )
+        )
+      ])
+    )
+  ];
+}
+
+// packages/compiler/src/jsx.ts
+function compileNode(path, state) {
+  if (path.isJSXFragment()) {
+    return t14.arrayExpression(compileChildren(path.node.children, state));
+  }
+  const node = path.node;
+  if (isComponentTag(node)) {
+    return compileComponent(path, state);
+  }
+  return state.firsthand.ssr ? compileMarkup(path, state) : compileTemplate(path, state);
+}
+function compileComponent(path, state) {
+  const node = path.node;
+  const run = enclosingRun(path, state);
+  const props = componentProps(path, run, state);
+  const feed = (value) => throughCell(value, run, props, state);
+  const children = compileChildren(node.children, state, {
+    depends: (value) => dependsOnRun(value, run, path),
+    cell: (value) => t14.callExpression(feed(t14.arrowFunctionExpression([], value)), []),
+    value: feed
+  });
+  if (children.length > 0) {
+    const returned = children.length === 1 ? children[0] : t14.arrayExpression(children);
+    props.properties.push(
+      t14.objectMethod(
+        "get",
+        t14.identifier("children"),
+        [],
+        t14.blockStatement([t14.returnStatement(returned)])
+      )
+    );
+  }
+  const tag = tagExpression(node.openingElement.name);
+  const local = isLocalView(path, state);
+  const make = local ? t14.callExpression(tag, [t14.objectExpression(props.properties)]) : t14.callExpression(runtime(state, "createComponent"), [
+    tag,
+    t14.objectExpression(props.properties)
+  ]);
+  if (run !== null) {
+    return keptChild(state, run, make, props.cells);
+  }
+  return local ? asScope(make, path, state) : make;
+}
+function asScope(make, path, state) {
+  if (state.firsthand.ssr) {
+    return make;
+  }
+  const parent = path.parentPath;
+  if (parent.isArrowFunctionExpression() && parent.node.body === path.node && CHILD_THUNK in parent.node) {
+    return make;
+  }
+  return t14.callExpression(runtime(state, "part"), [t14.arrowFunctionExpression([], make)]);
+}
+function componentProps(path, run, state) {
+  const props = { properties: [], cells: [] };
+  for (const attribute of path.node.openingElement.attributes) {
+    if (t14.isJSXSpreadAttribute(attribute)) {
+      props.properties.push(t14.spreadElement(attribute.argument));
+      continue;
+    }
+    const name = attributeName(attribute);
+    const value = attributeValue(attribute);
+    if (state.firsthand.ssr && name === "key") {
+      continue;
+    }
+    if (value === null || isStaticValue(value)) {
+      props.properties.push(t14.objectProperty(propertyKey(name), value ?? t14.booleanLiteral(true)));
+      continue;
+    }
+    const held = dependsOnRun(value, run, path) ? throughCell(value, run, props, state) : value;
+    props.properties.push(dynamicProp(name, value, held, state));
+  }
+  return props;
+}
+function dynamicProp(name, value, held, state) {
+  if (state.firsthand.ssr && isPure(value)) {
+    return t14.objectProperty(propertyKey(name), held);
+  }
+  const read = t14.returnStatement(held);
+  takePosition(read, value);
+  return t14.objectMethod("get", propertyKey(name), [], t14.blockStatement([read]));
+}
+function throughCell(value, run, props, state) {
+  const holder = t14.identifier(`_cell$${String(run.next())}`);
+  props.cells.push(
+    t14.variableDeclaration("const", [
+      t14.variableDeclarator(
+        holder,
+        t14.callExpression(runtime(state, "cell"), [
+          t14.cloneNode(run.store),
+          t14.numericLiteral(run.next()),
+          value
+        ])
+      )
+    ])
+  );
+  return t14.memberExpression(t14.cloneNode(holder), t14.identifier("value"));
+}
+function keptChild(state, run, make, cells) {
+  const slot = t14.identifier(`_kept$${String(run.next())}`);
+  const held = t14.identifier(`_own$${String(run.next())}`);
+  const made = () => t14.memberExpression(t14.cloneNode(slot), t14.identifier("last"));
+  const body = [
+    ...cells,
+    t14.variableDeclaration("const", [
+      t14.variableDeclarator(
+        slot,
+        t14.callExpression(runtime(state, "site"), [
+          t14.cloneNode(run.store),
+          t14.numericLiteral(run.next())
+        ])
+      )
+    ]),
+    t14.ifStatement(
+      t14.binaryExpression("===", made(), t14.identifier("undefined")),
+      t14.blockStatement([
+        t14.variableDeclaration("const", [
+          t14.variableDeclarator(
+            held,
+            t14.callExpression(runtime(state, "open"), [t14.cloneNode(run.store), t14.cloneNode(slot)])
+          )
+        ]),
+        expressionStatement2(
+          t14.assignmentExpression(
+            "=",
+            made(),
+            t14.callExpression(runtime(state, "part"), [t14.arrowFunctionExpression([], make)])
+          )
+        ),
+        expressionStatement2(t14.callExpression(runtime(state, "close"), [t14.cloneNode(held)]))
+      ])
+    ),
+    t14.returnStatement(made())
+  ];
+  return t14.callExpression(generated(t14.arrowFunctionExpression([], t14.blockStatement(body))), []);
+}
+function compileChildren(children, state, kept) {
+  const result = [];
+  for (const entry of planChildren(children)) {
+    if (entry.kind === "text") {
+      result.push(t14.stringLiteral(entry.text));
+    } else if (entry.kind === "element") {
+      result.push(entry.element);
+    } else if (state.firsthand.ssr) {
+      result.push(entry.expression);
+    } else if (entry.kind === "list") {
+      const list = entry.expression;
+      keepReading(list, kept);
+      result.push(t14.callExpression(runtime(state, "part"), [list]));
+    } else {
+      const value = entry.expression;
+      const read = kept !== void 0 && kept.depends(value) ? kept.cell(value) : value;
+      result.push(t14.callExpression(runtime(state, "part"), [thunk(read)]));
+    }
+  }
+  return result;
+}
+function keepReading(list, kept) {
+  const each = list.arguments[0];
+  if (kept === void 0 || !t14.isArrowFunctionExpression(each) || !t14.isExpression(each.body)) {
+    return;
+  }
+  if (!kept.depends(each.body)) {
+    return;
+  }
+  each.body = kept.value(each.body);
+}
+
+// packages/compiler/src/lists.ts
+import * as t15 from "@babel/types";
+function rewriteKeyedMaps(path, state) {
+  path.traverse({
+    CallExpression(call) {
+      const keyed = keyedMap(call);
+      if (keyed !== null) {
+        rewriteOne(call, keyed, state);
+      }
+    }
+  });
+}
+function keyedMap(call) {
+  if (!isChildPosition(call)) {
+    return null;
+  }
+  const callee = call.node.callee;
+  if (!t15.isMemberExpression(callee) || callee.computed || !t15.isIdentifier(callee.property, { name: "map" }) || call.node.arguments.length !== 1) {
+    return null;
+  }
+  const callback = call.get("arguments.0");
+  if (!callback.isArrowFunctionExpression() && !callback.isFunctionExpression()) {
+    return null;
+  }
+  const [item, index] = callback.node.params;
+  if (!t15.isIdentifier(item) || index !== void 0 && !t15.isIdentifier(index)) {
+    return null;
+  }
+  const root = keyedRoot(callback);
+  if (root === null) {
+    return null;
+  }
+  return { source: callee.object, callback, item, index, root };
+}
+function rewriteOne(call, keyed, state) {
+  const { callback, item, index, root } = keyed;
+  const keyExpression = t15.cloneNode(root.key);
+  root.element.openingElement.attributes = root.element.openingElement.attributes.filter(
+    (attribute) => attribute !== root.attribute
+  );
+  const itemCell = callback.scope.generateUidIdentifier("item");
+  const indexCell = callback.scope.generateUidIdentifier("index");
+  callback.scope.crawl();
+  liveRead(callback, item.name, itemCell);
+  if (index !== void 0) {
+    liveRead(callback, index.name, indexCell);
+  }
+  callback.node.params = [itemCell, indexCell];
+  const listCall = t15.callExpression(runtime(state, "list"), [
+    t15.arrowFunctionExpression([], keyed.source),
+    t15.arrowFunctionExpression(
+      [t15.cloneNode(item), index ?? callback.scope.generateUidIdentifier("i")],
+      keyExpression
+    ),
+    callback.node
+  ]);
+  listCall[LIST_CALL] = true;
+  call.replaceWith(listCall);
+  call.skip();
+}
+function isChildPosition(call) {
+  let child = call;
+  let parent = child.parentPath;
+  while (!parent.isJSXExpressionContainer()) {
+    const key = child.key;
+    const throughConditional = parent.isConditionalExpression() && (key === "consequent" || key === "alternate");
+    const throughLogical = parent.isLogicalExpression() && key === "right";
+    if (!throughConditional && !throughLogical) {
+      return false;
+    }
+    child = parent;
+    parent = parent.parentPath;
+  }
+  const holder = parent.parentPath;
+  return holder.isJSXElement() || holder.isJSXFragment();
+}
+function keyedRoot(callback) {
+  const body = callback.node.body;
+  let element = null;
+  if (t15.isJSXElement(body)) {
+    element = body;
+  } else if (t15.isBlockStatement(body)) {
+    const last = body.body[body.body.length - 1];
+    if (t15.isReturnStatement(last) && t15.isJSXElement(last.argument)) {
+      element = last.argument;
+    }
+  }
+  if (element === null || !t15.isJSXElement(element)) {
+    return null;
+  }
+  for (const attribute of element.openingElement.attributes) {
+    if (t15.isJSXAttribute(attribute) && t15.isJSXIdentifier(attribute.name, { name: "key" }) && t15.isJSXExpressionContainer(attribute.value)) {
+      return { element, attribute, key: attribute.value.expression };
+    }
+  }
+  return null;
+}
+function liveRead(scopePath, name, cell) {
+  const binding = scopePath.scope.getBinding(name);
+  for (const reference2 of binding.referencePaths) {
+    reference2.replaceWith(t15.memberExpression(t15.cloneNode(cell), t15.identifier("value")));
+  }
+}
+
+// packages/compiler/src/plugin.ts
+function firsthandPlugin(_api, options = {}) {
+  return {
+    name: "firsthand",
+    visitor: {
+      Program: {
+        enter(path, state) {
+          enterProgram(path, state, options);
+        },
+        exit(path, state) {
+          exitProgram(path, state);
+        }
+      },
+      // Babel enters the outermost JSX node first. Its nested elements are
+      // folded into the template and discarded; the nodes that survive (a
+      // component's children, a dynamic expression) are re-visited later, by
+      // which time they are no longer inside JSX.
+      JSXElement(path, state) {
+        if (!state.firsthand.ssr) {
+          rewriteKeyedMaps(path, state);
+        }
+        path.replaceWith(compileNode(path, state));
+      },
+      JSXFragment(path, state) {
+        if (!state.firsthand.ssr) {
+          rewriteKeyedMaps(path, state);
+        }
+        path.replaceWith(compileNode(path, state));
+      },
+      CallExpression(path, state) {
+        annotateComponent(path, state, options);
+      },
+      VariableDeclarator(path, state) {
+        if (options.devtools === true && options.ssr !== true) {
+          nameCell(path, state);
+        }
+      }
+    }
+  };
+}
+function enterProgram(path, state, options) {
+  state.firsthand = {
+    imports: /* @__PURE__ */ new Map(),
+    templates: [],
+    counter: 0,
+    moduleId: stableId(options.packageName ?? "app", state.filename ?? "module"),
+    views: /* @__PURE__ */ new Map(),
+    viewNodes: /* @__PURE__ */ new Set(),
+    runs: /* @__PURE__ */ new Map(),
+    ssr: options.ssr === true,
+    hydratable: options.hydratable === true && options.ssr !== true
+  };
+  collectViews(path, state);
+  if (options.ssr !== true) {
+    collectRuns(path, state);
+  }
+}
+function exitProgram(path, state) {
+  const { imports, templates, views } = state.firsthand;
+  for (const [, local] of views) {
+    path.node.body.push(
+      expressionStatement2(t16.callExpression(runtime(state, "view"), [t16.cloneNode(local)]))
+    );
+  }
+  if (templates.length > 0) {
+    path.node.body.unshift(t16.variableDeclaration("const", templates));
+  }
+  for (const [source, names] of groupBySource(imports)) {
+    path.node.body.unshift(
+      t16.importDeclaration(
+        names.map(([exported, local]) => t16.importSpecifier(local, t16.identifier(exported))),
+        t16.stringLiteral(source)
+      )
+    );
+  }
+}
+function groupBySource(imports) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [key, local] of imports) {
+    const separator = key.indexOf("#");
+    const source = key.slice(0, separator);
+    const exported = key.slice(separator + 1);
+    const bucket = grouped.get(source);
+    if (bucket === void 0) {
+      grouped.set(source, [[exported, local]]);
+    } else {
+      bucket.push([exported, local]);
+    }
+  }
+  return grouped;
+}
+
+// packages/compiler/src/api.ts
+import { transformSync } from "@babel/core";
+import jsxSyntax from "@babel/plugin-syntax-jsx";
+import typescriptSyntax from "@babel/plugin-syntax-typescript";
+function compileModule(code, options = {}) {
+  const result = transformSync(code, {
+    ...options.filename === void 0 ? {} : {
+      filename: options.filename,
+      // The full path, not the basename Babel would default to. A map
+      // whose `sources` is `comp.tsx` resolves, relative to a module
+      // served at `/src/comp.tsx`, to that very URL — so a debugger ends
+      // up with two files under one address, shows both, and puts the
+      // breakpoint in the wrong one.
+      sourceFileName: options.filename
+    },
+    babelrc: false,
+    configFile: false,
+    sourceMaps: options.sourceMaps === true,
+    plugins: buildPlugins(options)
+  });
+  return { code: result.code, map: result.map };
+}
+function transform(code, options = {}) {
+  return compileModule(code, options).code;
+}
+function buildPlugins(options) {
+  const plugins = [];
+  if (options.typescript === true) {
+    plugins.push([typescriptSyntax, { isTSX: true }]);
+  }
+  plugins.push(jsxSyntax);
+  plugins.push([
+    firsthandPlugin,
+    {
+      packageName: options.packageName,
+      strictReactivity: options.strictReactivity,
+      devtools: options.devtools,
+      ssr: options.ssr,
+      hydratable: options.hydratable
+    }
+  ]);
+  return plugins;
+}
+
+export {
+  stableId,
+  firsthandPlugin,
+  compileModule,
+  transform
+};