@firsthandjs/compiler 0.9.1 → 0.10.0

package/dist/chunk-GUVVHV7H.js

@@ -1,1845 +0,0 @@
-// 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/transform.ts
-import * as t 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();
-}
-
-// packages/compiler/src/transform.ts
-var RUNTIME = "@firsthandjs/dom/internal";
-var SERVER_RUNTIME = "@firsthandjs/server/internal";
-var CORE = "@firsthandjs/core";
-var CHILD_THUNK = /* @__PURE__ */ Symbol("firsthand.childThunk");
-var GENERATED = /* @__PURE__ */ Symbol("firsthand.generated");
-function generated(arrow) {
-  arrow[GENERATED] = true;
-  return arrow;
-}
-function pushOnce(build, statement) {
-  build.once.push(statement);
-}
-function pushEach(build, statement) {
-  build.each.push(statement);
-}
-function firsthandPlugin(_api, options = {}) {
-  return {
-    name: "firsthand",
-    visitor: {
-      Program: {
-        enter(path, state) {
-          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);
-          }
-        },
-        exit(path, state) {
-          const { imports, templates, views } = state.firsthand;
-          for (const [, local] of views) {
-            path.node.body.push(
-              expressionStatement2(t.callExpression(runtime(state, "view"), [t.cloneNode(local)]))
-            );
-          }
-          if (templates.length > 0) {
-            path.node.body.unshift(t.variableDeclaration("const", templates));
-          }
-          for (const [source, names] of groupBySource(imports)) {
-            path.node.body.unshift(
-              t.importDeclaration(
-                names.map(([exported, local]) => t.importSpecifier(local, t.identifier(exported))),
-                t.stringLiteral(source)
-              )
-            );
-          }
-        }
-      },
-      // 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 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;
-}
-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 = t.identifier(`_$${name}`);
-    state.firsthand.imports.set(key, local);
-  }
-  return t.cloneNode(local);
-}
-function annotateComponent(path, state, options) {
-  const callee = path.node.callee;
-  if (!t.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 (!t.isArrowFunctionExpression(setup) && !t.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] ?? t.identifier("undefined"),
-    t.stringLiteral(`${state.firsthand.moduleId}/${name}`),
-    t.stringLiteral(name)
-  ];
-}
-function checkKeptReads(setup, name) {
-  const parameter = setup.node.params[0];
-  const propsName = t.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 = t.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 report = (at) => {
-    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 />);`
-    );
-  };
-  const check = (returned, at) => {
-    if (t.isConditionalExpression(returned)) {
-      if (!hasView(returned.consequent) && !hasView(returned.alternate)) {
-        return;
-      }
-      if (readsSignal(returned.test)) {
-        report(at);
-      }
-      return;
-    }
-    if (t.isLogicalExpression(returned) && returned.operator !== "??") {
-      if (!hasView(returned.right) && !hasView(returned.left)) {
-        return;
-      }
-      if (readsSignal(returned.left)) {
-        report(at);
-      }
-    }
-  };
-  const body = setup.get("body");
-  if (!body.isBlockStatement()) {
-    check(setup.node.body, body);
-    return;
-  }
-  body.traverse({
-    Function(nested) {
-      nested.skip();
-    },
-    ReturnStatement(statement) {
-      const returned = statement.node.argument;
-      if (returned !== null && returned !== void 0) {
-        check(returned, statement);
-      }
-    },
-    /**
-     * 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)) {
-        report(statement.get("test"));
-      }
-    }
-  });
-}
-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 (!t.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 || !t.isMemberExpression(callee) || callee.computed || !t.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) => t.isJSXAttribute(attribute) && attributeName(attribute) === "key"
-  );
-}
-function returnsView(node) {
-  if (node === null || node === void 0) {
-    return false;
-  }
-  if (t.isReturnStatement(node)) {
-    return node.argument !== null && node.argument !== void 0 && hasView(node.argument);
-  }
-  if (t.isBlockStatement(node)) {
-    return node.body.some((inner) => returnsView(inner));
-  }
-  return false;
-}
-function hasView(node) {
-  if (t.isConditionalExpression(node)) {
-    return hasView(node.consequent) || hasView(node.alternate);
-  }
-  return t.isJSXElement(node) || t.isJSXFragment(node);
-}
-function readsSignal(node) {
-  let found = false;
-  const walk = (current) => {
-    if (current === null || current === void 0 || found) {
-      return;
-    }
-    if (t.isMemberExpression(current)) {
-      if (!current.computed && t.isIdentifier(current.property, { name: "value" })) {
-        found = true;
-        return;
-      }
-      walk(current.object);
-      return;
-    }
-    if (t.isUnaryExpression(current)) {
-      walk(current.argument);
-      return;
-    }
-    if (t.isBinaryExpression(current) || t.isLogicalExpression(current)) {
-      walk(current.left);
-      walk(current.right);
-      return;
-    }
-    if (t.isConditionalExpression(current)) {
-      walk(current.test);
-    }
-  };
-  walk(node);
-  return found;
-}
-function readsOnly(node, propsName) {
-  let read = false;
-  const walk = (current) => {
-    if (t.isIdentifier(current) || t.isLiteral(current)) {
-      if (t.isTemplateLiteral(current)) {
-        return current.expressions.every((part) => walk(part));
-      }
-      return true;
-    }
-    if (t.isMemberExpression(current)) {
-      const property = current.property;
-      if (!current.computed && t.isIdentifier(property, { name: "value" })) {
-        read = true;
-      }
-      if (propsName !== null && t.isIdentifier(current.object, { name: propsName })) {
-        read = true;
-      }
-      return walk(current.object) && (!current.computed || walk(property));
-    }
-    if (t.isUnaryExpression(current)) {
-      return walk(current.argument);
-    }
-    if (t.isBinaryExpression(current) || t.isLogicalExpression(current)) {
-      return walk(current.left) && walk(current.right);
-    }
-    if (t.isConditionalExpression(current)) {
-      return walk(current.test) && walk(current.consequent) && walk(current.alternate);
-    }
-    return false;
-  };
-  return walk(node) && read;
-}
-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 (!t.isCallExpression(init) || !t.isIdentifier(target) || !t.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 = t.callExpression(runtime(state, "label"), [
-    init,
-    t.stringLiteral(kind),
-    t.stringLiteral(`${target.name} (${where})`)
-  ]);
-  path.node.init = call;
-}
-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() && t.isIdentifier(parent.node.id)) {
-    return parent.node.id.name;
-  }
-  return "Component";
-}
-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 reads = [];
-  const restNames = [];
-  collectPattern(param.node, t.cloneNode(propsId), reads, restNames, call, name);
-  setup.scope.crawl();
-  const references = [];
-  for (const read of [...reads, ...restNames.map((r) => ({ local: r.local, access: propsId }))]) {
-    const binding = setup.scope.getBinding(read.local);
-    if (binding.constantViolations.length > 0) {
-      throw call.buildCodeFrameError(
-        `${name}: \`${read.local}\` is destructured from props and then assigned to. Props are readonly; assign to a signal instead.`
-      );
-    }
-    references.push({ paths: binding.referencePaths, access: read.access });
-  }
-  param.replaceWith(propsId);
-  for (const entry of references) {
-    for (const reference of entry.paths) {
-      if (entry.access !== propsId) {
-        reference.replaceWith(located(t.cloneNode(entry.access), reference.node));
-      }
-    }
-  }
-  if (restNames.length > 0) {
-    if (!setup.get("body").isBlockStatement()) {
-      const body = setup.node.body;
-      setup.node.body = t.blockStatement([t.returnStatement(body)]);
-    }
-    const block = setup.get("body");
-    for (const rest of restNames) {
-      block.node.body.unshift(
-        t.variableDeclaration("const", [
-          t.variableDeclarator(
-            t.identifier(rest.local),
-            t.callExpression(runtime(state, "rest"), [
-              t.cloneNode(propsId),
-              t.arrayExpression(rest.omit.map((key) => t.stringLiteral(key)))
-            ])
-          )
-        ])
-      );
-    }
-  }
-}
-function collectPattern(pattern, base, reads, rests, call, name) {
-  const seen = [];
-  for (const property of pattern.properties) {
-    if (t.isRestElement(property)) {
-      rests.push({ local: property.argument.name, omit: [...seen] });
-      continue;
-    }
-    if (property.computed || !t.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 = t.memberExpression(
-      t.cloneNode(base),
-      t.identifier(property.key.name)
-    );
-    const value = property.value;
-    if (t.isIdentifier(value)) {
-      reads.push({ local: value.name, access });
-    } else if (t.isAssignmentPattern(value) && t.isIdentifier(value.left)) {
-      reads.push({
-        local: value.left.name,
-        access: t.logicalExpression("??", access, value.right)
-      });
-    } else if (t.isObjectPattern(value)) {
-      collectPattern(value, access, reads, rests, call, name);
-    } 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.`
-      );
-    }
-  }
-}
-function compileNode(path, state) {
-  if (path.isJSXFragment()) {
-    return t.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 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, t.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 t.isProgram(fn.parentPath.scope.block) ? id.name : null;
-  }
-  const declarator = fn.parentPath;
-  if (!declarator.isVariableDeclarator() || !t.isIdentifier(declarator.node.id)) {
-    return null;
-  }
-  return t.isProgram(declarator.scope.block) ? declarator.node.id.name : null;
-}
-function isLocalView(path, state) {
-  const name = path.node.openingElement.name;
-  if (!t.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 (!t.isArrowFunctionExpression(init) && !t.isFunctionExpression(init)) {
-    return false;
-  }
-  return state.firsthand.viewNodes.has(init);
-}
-function collectRuns(program, state) {
-  program.traverse({
-    CallExpression(call) {
-      if (!isComponentCall(call)) {
-        return;
-      }
-      const setup = call.get("arguments.0");
-      if (!setup.isArrowFunctionExpression() && !setup.isFunctionExpression()) {
-        return;
-      }
-      const found = [];
-      const body = setup.get("body");
-      if (!body.isBlockStatement()) {
-        if (body.isArrowFunctionExpression() || body.isFunctionExpression()) {
-          found.push(body);
-        }
-      } else {
-        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);
-            }
-          }
-        });
-      }
-      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",
-          t.variableDeclaration("const", [
-            t.variableDeclarator(
-              store,
-              t.callExpression(runtime(state, "store"), [t.stringLiteral(declaredName(call))])
-            )
-          ])
-        );
-        let index = 0;
-        state.firsthand.runs.set(run.node, {
-          node: run.node,
-          store,
-          next: () => index++
-        });
-        closeRun(run, store, state);
-      }
-    }
-  });
-}
-function closeRun(run, store, state) {
-  const body = run.get("body");
-  if (!body.isBlockStatement()) {
-    body.replaceWith(
-      t.callExpression(runtime(state, "ran"), [t.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 = t.callExpression(runtime(state, "ran"), [
-      t.cloneNode(store),
-      statement.node.argument ?? t.identifier("undefined")
-    ]);
-  }
-}
-function isComponentCall(path) {
-  if (!t.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 (t.isIdentifier(node)) {
-    into.add(node.name);
-    return;
-  }
-  for (const key of t.VISITOR_KEYS[node.type]) {
-    if (t.isMemberExpression(node) && !node.computed && key === "property") {
-      continue;
-    }
-    if ((t.isObjectProperty(node) || t.isObjectMethod(node)) && !node.computed && key === "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 canRetain(node, build) {
-  let possible = true;
-  const visit = (element) => {
-    for (const attribute of element.openingElement.attributes) {
-      if (t.isJSXSpreadAttribute(attribute)) {
-        if (dependsOnRun(attribute.argument, build.run, build.at)) {
-          possible = false;
-        }
-        continue;
-      }
-      const value = attribute.value;
-      if (attributeName(attribute) === "ref" && t.isJSXExpressionContainer(value) && !t.isJSXEmptyExpression(value.expression) && dependsOnRun(value.expression, build.run, build.at)) {
-        possible = false;
-      }
-    }
-    for (const child of element.children) {
-      if (t.isJSXElement(child)) {
-        if (!isComponentTag(child)) {
-          visit(child);
-        }
-        continue;
-      }
-      if (t.isJSXExpressionContainer(child) && !t.isJSXEmptyExpression(child.expression) && isKeyedList(child.expression) && dependsOnRun(child.expression, build.run, build.at)) {
-        possible = false;
-      }
-    }
-  };
-  visit(node);
-  return possible;
-}
-function isKeyedList(node) {
-  return t.isCallExpression(node) && LIST_CALL in node;
-}
-function isComponentTag(node) {
-  const name = node.openingElement.name;
-  if (t.isJSXMemberExpression(name)) {
-    return true;
-  }
-  if (!t.isJSXIdentifier(name)) {
-    return false;
-  }
-  return /^[A-Z]/.test(name.name);
-}
-function tagExpression(name) {
-  if (t.isJSXIdentifier(name)) {
-    return t.identifier(name.name);
-  }
-  return t.memberExpression(tagExpression(name.object), t.identifier(name.property.name));
-}
-function compileComponent(path, state) {
-  const node = path.node;
-  const run = enclosingRun(path, state);
-  const properties = [];
-  const cells = [];
-  const throughCell = (value) => {
-    const holder = t.identifier(`_cell$${String(run.next())}`);
-    cells.push(
-      t.variableDeclaration("const", [
-        t.variableDeclarator(
-          holder,
-          t.callExpression(runtime(state, "cell"), [
-            t.cloneNode(run.store),
-            t.numericLiteral(run.next()),
-            value
-          ])
-        )
-      ])
-    );
-    return t.memberExpression(t.cloneNode(holder), t.identifier("value"));
-  };
-  for (const attribute of node.openingElement.attributes) {
-    if (t.isJSXSpreadAttribute(attribute)) {
-      properties.push(t.spreadElement(attribute.argument));
-      continue;
-    }
-    const name = attributeName(attribute);
-    const value = attributeValue(attribute);
-    if (state.firsthand.ssr && name === "key") {
-      continue;
-    }
-    if (value === null || isStaticValue(value)) {
-      properties.push(t.objectProperty(propertyKey(name), value ?? t.booleanLiteral(true)));
-    } else {
-      const held = dependsOnRun(value, run, path) ? throughCell(value) : value;
-      if (state.firsthand.ssr && isPure(value)) {
-        properties.push(t.objectProperty(propertyKey(name), held));
-      } else {
-        const read = t.returnStatement(held);
-        takePosition(read, value);
-        properties.push(t.objectMethod("get", propertyKey(name), [], t.blockStatement([read])));
-      }
-    }
-  }
-  const throughRunCell = (value) => t.callExpression(throughCell(t.arrowFunctionExpression([], value)), []);
-  const children = compileChildren(node.children, state, {
-    depends: (value) => dependsOnRun(value, run, path),
-    cell: throughRunCell,
-    value: throughCell
-  });
-  if (children.length === 1) {
-    properties.push(
-      t.objectMethod(
-        "get",
-        t.identifier("children"),
-        [],
-        t.blockStatement([t.returnStatement(children[0])])
-      )
-    );
-  } else if (children.length > 1) {
-    properties.push(
-      t.objectMethod(
-        "get",
-        t.identifier("children"),
-        [],
-        t.blockStatement([t.returnStatement(t.arrayExpression(children))])
-      )
-    );
-  }
-  const tag = tagExpression(node.openingElement.name);
-  const make = isLocalView(path, state) ? t.callExpression(tag, [t.objectExpression(properties)]) : t.callExpression(runtime(state, "createComponent"), [tag, t.objectExpression(properties)]);
-  if (run !== null) {
-    return keptChild(state, run, make, cells);
-  }
-  if (isLocalView(path, state)) {
-    if (state.firsthand.ssr) {
-      return make;
-    }
-    const parent = path.parentPath;
-    if (parent.isArrowFunctionExpression() && parent.node.body === node && CHILD_THUNK in parent.node) {
-      return make;
-    }
-    return t.callExpression(runtime(state, "part"), [t.arrowFunctionExpression([], make)]);
-  }
-  return make;
-}
-function keptChild(state, run, make, cells) {
-  const slot = t.identifier(`_kept$${String(run.next())}`);
-  const held = t.identifier(`_own$${String(run.next())}`);
-  const made = () => t.memberExpression(t.cloneNode(slot), t.identifier("last"));
-  const body = [
-    ...cells,
-    t.variableDeclaration("const", [
-      t.variableDeclarator(
-        slot,
-        t.callExpression(runtime(state, "site"), [
-          t.cloneNode(run.store),
-          t.numericLiteral(run.next())
-        ])
-      )
-    ]),
-    t.ifStatement(
-      t.binaryExpression("===", made(), t.identifier("undefined")),
-      t.blockStatement([
-        t.variableDeclaration("const", [
-          t.variableDeclarator(
-            held,
-            t.callExpression(runtime(state, "open"), [t.cloneNode(run.store), t.cloneNode(slot)])
-          )
-        ]),
-        expressionStatement2(
-          t.assignmentExpression(
-            "=",
-            made(),
-            t.callExpression(runtime(state, "part"), [t.arrowFunctionExpression([], make)])
-          )
-        ),
-        expressionStatement2(t.callExpression(runtime(state, "close"), [t.cloneNode(held)]))
-      ])
-    ),
-    t.returnStatement(made())
-  ];
-  return t.callExpression(generated(t.arrowFunctionExpression([], t.blockStatement(body))), []);
-}
-function isPure(node) {
-  switch (node.type) {
-    case "Identifier":
-    case "ThisExpression":
-    case "StringLiteral":
-    case "NumericLiteral":
-    case "BooleanLiteral":
-    case "NullLiteral":
-    case "BigIntLiteral":
-    case "RegExpLiteral":
-      return true;
-    case "MemberExpression":
-    case "OptionalMemberExpression":
-      return isPure(node.object) && (!node.computed || isPure(node.property));
-    case "UnaryExpression":
-      return node.operator !== "delete" && isPure(node.argument);
-    case "BinaryExpression":
-      return isPure(node.left) && isPure(node.right);
-    case "LogicalExpression":
-      return isPure(node.left) && isPure(node.right);
-    case "ConditionalExpression":
-      return isPure(node.test) && isPure(node.consequent) && isPure(node.alternate);
-    case "TemplateLiteral":
-      return node.expressions.every((one) => t.isExpression(one) && isPure(one));
-    case "ArrayExpression":
-      return node.elements.every((one) => one === null || t.isExpression(one) && isPure(one));
-    case "ObjectExpression":
-      return node.properties.every(
-        (one) => t.isObjectProperty(one) && !one.computed && t.isExpression(one.value) && isPure(one.value)
-      );
-    default:
-      return false;
-  }
-}
-function propertyKey(name) {
-  return t.isValidIdentifier(name) ? t.identifier(name) : t.stringLiteral(name);
-}
-function attributeName(attribute) {
-  const name = attribute.name;
-  return t.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 (t.isStringLiteral(value)) {
-    return value;
-  }
-  if (t.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 t.isStringLiteral(value) || t.isNumericLiteral(value) || t.isBooleanLiteral(value) || t.isNullLiteral(value);
-}
-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 t.callExpression(runtime(state, "ssr"), [
-      t.arrayExpression([t.stringLiteral(markup.parts[0])])
-    ]);
-  }
-  return t.callExpression(runtime(state, "ssr"), [
-    t.arrayExpression(markup.parts.map((part) => t.stringLiteral(part))),
-    ...markup.values
-  ]);
-}
-function emitMarkupElement(node, markup, state) {
-  const name = node.openingElement.name;
-  if (!t.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 (t.isJSXSpreadAttribute(attribute)) {
-    pushHole(markup, t.callExpression(runtime(state, "spread"), [attribute.argument]));
-    return;
-  }
-  const name = attributeName(attribute);
-  const value = attributeValue(attribute);
-  if (name === "ref" || name.startsWith("on") && name.length > 2 && /[A-Z:]/.test(name[2])) {
-    return;
-  }
-  if (name === "key") {
-    return;
-  }
-  if (value === null) {
-    pushText(markup, ` ${name}=""`);
-    return;
-  }
-  if (isStaticValue(value)) {
-    if (t.isBooleanLiteral(value) && !value.value) {
-      return;
-    }
-    if (t.isNullLiteral(value)) {
-      return;
-    }
-    const literal = t.isStringLiteral(value) ? value.value : t.isNumericLiteral(value) ? String(value.value) : "";
-    pushText(markup, ` ${name}="${escapeAttribute(literal)}"`);
-    return;
-  }
-  pushHole(markup, markupAttributeCall(name, value, state));
-}
-function markupAttributeCall(name, value, state) {
-  if (name.startsWith("prop:")) {
-    return t.callExpression(runtime(state, "setProperty"), [t.stringLiteral(name.slice(5)), value]);
-  }
-  if (name.startsWith("attr:")) {
-    return t.callExpression(runtime(state, "setAttribute"), [
-      t.stringLiteral(name.slice(5)),
-      value
-    ]);
-  }
-  if (name === "class" || name === "className") {
-    return t.callExpression(runtime(state, "setClass"), [value]);
-  }
-  if (name === "style") {
-    return t.callExpression(runtime(state, "setStyle"), [value]);
-  }
-  if (BOOLEAN_PROPERTIES.has(name)) {
-    return t.callExpression(runtime(state, "setBoolean"), [t.stringLiteral(name), value]);
-  }
-  if (DOM_PROPERTIES.has(name)) {
-    return t.callExpression(runtime(state, "setProperty"), [t.stringLiteral(name), value]);
-  }
-  return t.callExpression(runtime(state, "setAttribute"), [t.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, t.callExpression(runtime(state, "child"), [entry.expression]));
-    if (i !== entries.length - 1) {
-      pushText(markup, "<!---->");
-    }
-  }
-}
-function compileTemplate(path, state) {
-  let names = 0;
-  const statements = [];
-  const build = {
-    html: [],
-    statements,
-    // Where a site is built once, these are three lists; where it is not, they
-    // are one, and everything simply happens in the order it was written.
-    once: statements,
-    each: statements,
-    run: null,
-    at: path,
-    next: /* @__PURE__ */ (() => {
-      let n = 0;
-      return () => t.identifier(`_el$${String(++n)}`);
-    })(),
-    name: (prefix) => t.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;
-    }
-  }
-  const kept = build.run !== null;
-  const root = t.identifier("_el$");
-  emitElement(path.node, build, root, state);
-  const templateId = t.identifier(`_tmpl$${String(++state.firsthand.counter)}`);
-  state.firsthand.templates.push(
-    t.variableDeclarator(
-      templateId,
-      t.addComment(
-        t.callExpression(runtime(state, "template"), [t.stringLiteral(build.html.join(""))]),
-        "leading",
-        "#__PURE__"
-      )
-    )
-  );
-  if (!kept) {
-    const body2 = [
-      t.variableDeclaration("const", [
-        t.variableDeclarator(root, t.callExpression(t.cloneNode(templateId), []))
-      ]),
-      ...build.statements,
-      t.returnStatement(t.cloneNode(root))
-    ];
-    return t.callExpression(generated(t.arrowFunctionExpression([], t.blockStatement(body2))), []);
-  }
-  const slot = build.name("_site$");
-  const fresh = build.name("_new$");
-  const held = build.name("_own$");
-  const owner = build.run;
-  const body = [
-    t.variableDeclaration("const", [
-      t.variableDeclarator(
-        slot,
-        t.callExpression(runtime(state, "site"), [
-          t.cloneNode(owner.store),
-          t.numericLiteral(owner.next())
-        ])
-      )
-    ]),
-    t.variableDeclaration("let", [
-      t.variableDeclarator(root, t.memberExpression(t.cloneNode(slot), t.identifier("node")))
-    ]),
-    t.variableDeclaration("const", [
-      t.variableDeclarator(
-        fresh,
-        t.binaryExpression("===", t.cloneNode(root), t.identifier("undefined"))
-      )
-    ]),
-    t.variableDeclaration("let", [t.variableDeclarator(held)]),
-    t.ifStatement(
-      t.cloneNode(fresh),
-      t.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(
-          t.assignmentExpression(
-            "=",
-            t.cloneNode(held),
-            t.callExpression(runtime(state, "open"), [t.cloneNode(owner.store), t.cloneNode(slot)])
-          )
-        ),
-        expressionStatement2(
-          t.assignmentExpression(
-            "=",
-            t.cloneNode(root),
-            t.assignmentExpression(
-              "=",
-              t.memberExpression(t.cloneNode(slot), t.identifier("node")),
-              t.callExpression(t.cloneNode(templateId), [])
-            )
-          )
-        )
-      ])
-    ),
-    ...build.statements,
-    t.ifStatement(
-      t.cloneNode(fresh),
-      t.blockStatement([
-        ...build.once,
-        expressionStatement2(t.callExpression(runtime(state, "close"), [t.cloneNode(held)]))
-      ])
-    )
-  ];
-  body.push(...build.each, t.returnStatement(t.cloneNode(root)));
-  return t.callExpression(generated(t.arrowFunctionExpression([], t.blockStatement(body))), []);
-}
-function guardedWrite(build, state, value, write) {
-  const run = build.run;
-  const slot = build.name("_w$");
-  const held = build.name("_x$");
-  const last = () => t.memberExpression(t.cloneNode(slot), t.identifier("last"));
-  pushEach(
-    build,
-    t.variableDeclaration("const", [
-      t.variableDeclarator(
-        slot,
-        t.callExpression(runtime(state, "site"), [
-          t.cloneNode(run.store),
-          t.numericLiteral(run.next())
-        ])
-      ),
-      t.variableDeclarator(held, value)
-    ])
-  );
-  pushEach(
-    build,
-    t.ifStatement(
-      t.binaryExpression("!==", last(), t.cloneNode(held)),
-      t.blockStatement([
-        expressionStatement2(t.assignmentExpression("=", last(), t.cloneNode(held))),
-        expressionStatement2(t.callExpression(runtime(state, "wrote"), [t.cloneNode(run.store)])),
-        expressionStatement2(write(t.cloneNode(held)))
-      ])
-    )
-  );
-}
-function emitElement(node, build, self, state) {
-  const name = node.openingElement.name;
-  if (!t.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 deferred = [];
-  for (const attribute of node.openingElement.attributes) {
-    emitAttribute(attribute, build, self, state, deferred, tag);
-  }
-  build.html.push(">");
-  for (const emit of deferred) {
-    emit();
-  }
-  emitChildren(node.children, build, self, state);
-  if (!VOID_ELEMENTS.has(tag)) {
-    build.html.push(`</${tag}>`);
-  }
-}
-function emitAttribute(attribute, build, self, state, deferred, tag) {
-  if (t.isJSXSpreadAttribute(attribute)) {
-    deferred.push(() => {
-      pushOnce(
-        build,
-        expressionStatement2(
-          t.callExpression(runtime(state, "bind"), [
-            t.arrowFunctionExpression(
-              [],
-              t.callExpression(runtime(state, "spread"), [t.cloneNode(self), attribute.argument])
-            )
-          ])
-        )
-      );
-    });
-    return;
-  }
-  const name = attributeName(attribute);
-  const value = attributeValue(attribute);
-  if (name === "ref") {
-    deferred.push(() => {
-      pushOnce(
-        build,
-        expressionStatement2(t.callExpression(value, [t.cloneNode(self)]))
-      );
-    });
-    return;
-  }
-  if (name.startsWith("on") && name.length > 2 && /[A-Z:]/.test(name[2])) {
-    const parts = name.split(":");
-    const literal = parts[0] === "on";
-    const type = literal ? parts[1] : eventName(parts[0]);
-    const modifier = parts[literal ? 2 : 1];
-    deferred.push(() => {
-      const args = [
-        t.cloneNode(self),
-        t.stringLiteral(type),
-        value
-      ];
-      if (modifier === "native") {
-        args.push(t.booleanLiteral(true));
-      } else if (modifier !== void 0) {
-        args.push(
-          t.objectExpression([t.objectProperty(propertyKey(modifier), t.booleanLiteral(true))])
-        );
-      }
-      const attach = expressionStatement2(t.callExpression(runtime(state, "on"), args));
-      if (dependsOnRun(value, build.run, build.at)) {
-        pushEach(build, attach);
-      } else {
-        pushOnce(build, attach);
-      }
-    });
-    return;
-  }
-  if (value !== null && isStaticValue(value) && canInlineAttribute(name)) {
-    if (t.isBooleanLiteral(value) && !value.value) {
-      return;
-    }
-    if (t.isNullLiteral(value)) {
-      return;
-    }
-    const literal = t.isStringLiteral(value) ? value.value : t.isNumericLiteral(value) ? String(value.value) : "";
-    build.html.push(` ${name}="${escapeAttribute(literal)}"`);
-    return;
-  }
-  if (value === null) {
-    build.html.push(` ${name}=""`);
-    return;
-  }
-  deferred.push(() => {
-    if (dependsOnRun(value, build.run, build.at)) {
-      guardedWrite(
-        build,
-        state,
-        value,
-        (held) => dynamicAttributeCall(name, held, self, state, tag)
-      );
-      return;
-    }
-    pushOnce(
-      build,
-      expressionStatement2(
-        t.callExpression(runtime(state, "bind"), [
-          located(
-            t.arrowFunctionExpression([], dynamicAttributeCall(name, value, self, state, tag)),
-            value
-          )
-        ])
-      )
-    );
-  });
-}
-function canInlineAttribute(name) {
-  return !name.startsWith("prop:") && !name.startsWith("attr:") && !DOM_PROPERTIES.has(name) && !BOOLEAN_PROPERTIES.has(name);
-}
-function dynamicAttributeCall(name, value, self, state, tag) {
-  if (name.startsWith("prop:")) {
-    return t.callExpression(runtime(state, "setProperty"), [
-      t.cloneNode(self),
-      t.stringLiteral(name.slice(5)),
-      value
-    ]);
-  }
-  if (name.startsWith("attr:")) {
-    return t.callExpression(runtime(state, "setAttribute"), [
-      t.cloneNode(self),
-      t.stringLiteral(name.slice(5)),
-      value
-    ]);
-  }
-  if (name === "class" || name === "className" || name === "style") {
-    return t.callExpression(runtime(state, "applyProp"), [
-      t.cloneNode(self),
-      t.stringLiteral(name),
-      value
-    ]);
-  }
-  if (BOOLEAN_PROPERTIES.has(name)) {
-    return t.callExpression(runtime(state, "setBoolean"), [
-      t.cloneNode(self),
-      t.stringLiteral(name),
-      value
-    ]);
-  }
-  if (DOM_PROPERTIES.has(name) && !SVG_ELEMENTS.has(tag)) {
-    return t.callExpression(runtime(state, "setProperty"), [
-      t.cloneNode(self),
-      t.stringLiteral(name),
-      value
-    ]);
-  }
-  return t.callExpression(runtime(state, "setAttribute"), [
-    t.cloneNode(self),
-    t.stringLiteral(name),
-    value
-  ]);
-}
-var LIST_CALL = /* @__PURE__ */ Symbol("firsthand.list");
-function rewriteKeyedMaps(path, state) {
-  path.traverse({
-    CallExpression(call) {
-      if (!isChildPosition(call)) {
-        return;
-      }
-      const callee = call.node.callee;
-      if (!t.isMemberExpression(callee) || callee.computed || !t.isIdentifier(callee.property, { name: "map" }) || call.node.arguments.length !== 1) {
-        return;
-      }
-      const callback = call.get("arguments.0");
-      if (!callback.isArrowFunctionExpression() && !callback.isFunctionExpression()) {
-        return;
-      }
-      const params = callback.node.params;
-      const itemParam = params[0];
-      const indexParam = params[1];
-      if (!t.isIdentifier(itemParam) || indexParam !== void 0 && !t.isIdentifier(indexParam)) {
-        return;
-      }
-      const root = keyedRoot(callback);
-      if (root === null) {
-        return;
-      }
-      const keyExpression = t.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, itemParam.name, itemCell);
-      if (indexParam !== void 0) {
-        liveRead(callback, indexParam.name, indexCell);
-      }
-      callback.node.params = [itemCell, indexCell];
-      const listCall = t.callExpression(runtime(state, "list"), [
-        t.arrowFunctionExpression([], callee.object),
-        t.arrowFunctionExpression(
-          [t.cloneNode(itemParam), indexParam ?? 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 (t.isJSXElement(body)) {
-    element = body;
-  } else if (t.isBlockStatement(body)) {
-    const last = body.body[body.body.length - 1];
-    if (t.isReturnStatement(last) && t.isJSXElement(last.argument)) {
-      element = last.argument;
-    }
-  }
-  if (element === null || !t.isJSXElement(element)) {
-    return null;
-  }
-  for (const attribute of element.openingElement.attributes) {
-    if (t.isJSXAttribute(attribute) && t.isJSXIdentifier(attribute.name, { name: "key" }) && t.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 reference of binding.referencePaths) {
-    reference.replaceWith(t.memberExpression(t.cloneNode(cell), t.identifier("value")));
-  }
-}
-function emitChildren(children, build, self, state) {
-  const entries = planChildren(children);
-  let previous = null;
-  let previousIndex = 0;
-  let index = 0;
-  const reference = () => {
-    const id = build.next();
-    build.statements.push(
-      t.variableDeclaration("const", [
-        t.variableDeclarator(id, navigate(self, previous, previousIndex, index, state))
-      ])
-    );
-    previous = id;
-    previousIndex = index;
-    return id;
-  };
-  for (let i = 0; i < entries.length; i++) {
-    const entry = entries[i];
-    if (entry.kind === "text") {
-      build.html.push(escapeText(entry.text));
-      index++;
-      continue;
-    }
-    if (entry.kind === "element") {
-      const element = entry.element;
-      if (needsReference(element)) {
-        const id = reference();
-        emitElement(element, build, id, state);
-      } else {
-        emitElement(element, build, t.identifier("_unused$"), state);
-      }
-      index++;
-      continue;
-    }
-    const isLast = i === entries.length - 1;
-    const expression = entry.expression;
-    let marker = null;
-    if (!isLast) {
-      build.html.push("<!>");
-      marker = t.cloneNode(reference());
-    }
-    if (entry.kind !== "list" && dependsOnRun(expression, build.run, build.at)) {
-      const run = build.run;
-      pushEach(
-        build,
-        expressionStatement2(
-          t.callExpression(runtime(state, "writeChild"), [
-            t.cloneNode(run.store),
-            t.numericLiteral(run.next()),
-            t.cloneNode(self),
-            marker ?? t.nullLiteral(),
-            expression
-          ])
-        )
-      );
-      index++;
-      continue;
-    }
-    const args = [
-      t.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" ? expression : thunk(expression)
-    ];
-    if (marker !== null) {
-      args.push(marker);
-    }
-    pushOnce(build, expressionStatement2(t.callExpression(runtime(state, "insert"), args)));
-    index++;
-  }
-}
-function needsReference(element) {
-  for (const attribute of element.openingElement.attributes) {
-    if (t.isJSXSpreadAttribute(attribute)) {
-      return true;
-    }
-    const name = attributeName(attribute);
-    if (name === "ref" || name.startsWith("on")) {
-      return true;
-    }
-    const value = attributeValue(attribute);
-    if (value !== null && (!isStaticValue(value) || !canInlineAttribute(name))) {
-      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 navigate(self, previous, previousIndex, index, state) {
-  const hydratable = state.firsthand.hydratable;
-  const first = hydratable ? runtime(state, "first") : null;
-  const next = hydratable ? runtime(state, "next") : null;
-  let expression;
-  let steps;
-  if (previous === null) {
-    expression = hydratable ? t.callExpression(first, [t.cloneNode(self)]) : t.memberExpression(t.cloneNode(self), t.identifier("firstChild"));
-    steps = index;
-  } else {
-    expression = t.cloneNode(previous);
-    steps = index - previousIndex;
-  }
-  for (let i = 0; i < steps; i++) {
-    expression = hydratable ? t.callExpression(next, [expression]) : t.memberExpression(expression, t.identifier("nextSibling"));
-  }
-  return expression;
-}
-function planChildren(children) {
-  const entries = [];
-  let pending = "";
-  const flush = () => {
-    if (pending !== "") {
-      entries.push({ kind: "text", text: pending });
-      pending = "";
-    }
-  };
-  for (const child of children) {
-    if (t.isJSXText(child)) {
-      pending += cleanText(child.value);
-      continue;
-    }
-    if (t.isJSXExpressionContainer(child)) {
-      const expression = child.expression;
-      if (t.isJSXEmptyExpression(expression)) {
-        continue;
-      }
-      if (t.isStringLiteral(expression) || t.isNumericLiteral(expression)) {
-        pending += String(expression.value);
-        continue;
-      }
-      flush();
-      const isList = expression[LIST_CALL] === true;
-      entries.push({ kind: isList ? "list" : "dynamic", expression });
-      continue;
-    }
-    flush();
-    if (t.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 compileChildren(children, state, kept) {
-  const result = [];
-  for (const entry of planChildren(children)) {
-    if (entry.kind === "text") {
-      result.push(t.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(t.callExpression(runtime(state, "part"), [list]));
-    } else {
-      const value = entry.expression;
-      const read = kept !== void 0 && kept.depends(value) ? kept.cell(value) : value;
-      result.push(t.callExpression(runtime(state, "part"), [thunk(read)]));
-    }
-  }
-  return result;
-}
-function keepReading(list, kept) {
-  const each = list.arguments[0];
-  if (kept === void 0 || !t.isArrowFunctionExpression(each) || !t.isExpression(each.body)) {
-    return;
-  }
-  if (!kept.depends(each.body)) {
-    return;
-  }
-  each.body = kept.value(each.body);
-}
-function thunk(expression) {
-  const arrow = t.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(t.expressionStatement(expression), expression);
-}
-function located(node, source) {
-  if (source == null || source.loc == null) {
-    return node;
-  }
-  node.loc = source.loc;
-  return node;
-}
-
-// 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
-};