jq79 0.5.13 → 0.6.0

package/dist/jq79.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/jq79.ts","../src/dom.ts","../src/reactive.ts","../src/transform.ts"],"sourcesContent":["\nimport { $, $$, $create, sanitizeHTML, allowedHosts } from \"./dom\"\nimport type { AllowUrl } from \"./dom\"\nimport { $reactive, $toRaw, untracked, createEffectScope, ALSO_WAKEN_BY } from \"./reactive\"\nimport type { ReactiveDeepData, EffectScope } from \"./reactive\"\nimport { transformSetupScript, transformFactoryScript, parsePropsPattern, parseFactoryProps, type PropDecl } from \"./transform\"\n\nexport { $, $$, $create } from \"./dom\"\nexport { $reactive, $toRaw } from \"./reactive\"\n\n// the package version, substituted at build time (tsup/vitest `define`, read\n// from package.json - releases bump it there and nowhere else). The typeof\n// guard is what keeps the raw source runnable: tests and any bundler that\n// doesn't define it see a bare identifier, not a ReferenceError\ndeclare const __JQ79_VERSION__: string\nconst VERSION = typeof __JQ79_VERSION__ === \"string\" ? __JQ79_VERSION__ : \"0.0.0-dev\"\n\ntype TemplateNode = {\n  tag: string\n  attrs: Record<string, string>\n  children: (TemplateNode | string)[]\n  // the tag as the author capitalized it, present only when they wrote it\n  // uppercase-initial - i.e. when they meant a component. `tag` cannot answer\n  // this: the HTML parser lowercases it, so the claim is captured before the\n  // parse (see stampComponentTag) and lifted off attrs here, where it stops\n  // looking like an attribute to every loop downstream\n  component?: string\n}\n\ntype TagBlock = {\n  attrs: Record<string, string>\n  content: string\n  // <style scoped> only: `content` rewritten to require the component's scope\n  // attribute. Kept beside the original rather than replacing it, because a\n  // shadow root doesn't want it - see headStyle()\n  scoped?: string\n}\n\nconst elementAttrs = (el: Element): Record<string, string> =>\n  Object.fromEntries(Array.from(el.attributes).map(attr => [attr.name, attr.value]))\n\n// text is kept verbatim - not trimmed, not dropped when it's only whitespace.\n// A template is HTML, so the space in `<span>a</span>\\n<span>b</span>` is the\n// same space the browser would collapse-and-render between them, and CSS gets\n// to decide what it's worth (nothing in a block or flex container, one space\n// between inline elements). Trimming it here, as this used to, silently glued\n// siblings together and ate the spaces in `hola <b>mundo</b> adios`\n//\n// A <template>'s children are read from its .content fragment: that is where\n// the HTML parser puts them, and its childNodes are empty. Without the descent\n// they are not in the AST at all - which is where slot content is written\n// (<template :slot.name>), and why a nested <template> used to render as an\n// empty element whatever was inside it\nconst elementToAST = (el: Element): TemplateNode => {\n  const attrs = elementAttrs(el)\n  // the pre-parse stamp becomes a field and leaves attrs entirely: it is not a\n  // prop, not a directive and not an attribute, and every loop that walks attrs\n  // would otherwise need to know its name\n  const component = attrs[COMPONENT_TAG_ATTR]\n  delete attrs[COMPONENT_TAG_ATTR]\n  return {\n    tag: el.tagName.toLowerCase(),\n    attrs,\n    ...(component === undefined ? {} : { component }),\n    children: Array.from((el instanceof HTMLTemplateElement ? el.content : el).childNodes).flatMap((node): (TemplateNode | string)[] => {\n      if (node.nodeType === Node.TEXT_NODE) {\n        const text = node.textContent ?? \"\"\n        return text ? [text] : []\n      }\n      if (node.nodeType === Node.ELEMENT_NODE) {\n        return [elementToAST(node as Element)]\n      }\n      return []\n    })\n  }\n}\n\n// evaluated with `with` (rather than passing scope keys as positional params)\n// so only the identifiers an expression actually references are read from\n// `scope` - which is what makes dependency tracking in $reactive\n// precise instead of \"read everything up front\". `extras` are passed as\n// function parameters (outside the `with`), so scope keys still win but names\n// like $event resolve when the scope doesn't shadow them\n//\n// Compiled functions are cached: an expression is re-evaluated on every effect\n// run - once per interpolation, once per :each item - while the set of distinct\n// expressions is fixed by the source. The `extras` names are part of the key,\n// not just the expression: they become the function's parameters, so the same\n// expression compiled with and without $event is two different functions. A\n// syntactically invalid expression caches its failure (null) so it isn't\n// recompiled, and rethrown as undefined, exactly as before\nconst compiled = new Map<string, Function | null>()\n\nconst compileExpr = (expr: string, params: string[]): Function | null => {\n  const key = `${params.join(\",\")}|${expr}`\n  let fn = compiled.get(key)\n  if (fn === undefined) {\n    try {\n      // the newline before `)` ends a trailing line comment in the\n      // expression ({{ msg // greeting }}); ASI doesn't apply inside parens,\n      // so everything else is untouched. Without it the comment eats the\n      // rest of this single-line body and the expression never compiles\n      fn = new Function(\"$scope\", ...params, `with ($scope) { return (${expr}\\n); }`)\n    } catch {\n      fn = null // a syntax error: it will never compile, so don't try again\n    }\n    compiled.set(key, fn)\n  }\n  return fn\n}\n\n// a template expression is re-evaluated constantly - once per effect run, once\n// per interpolation, once per :each item - so a value that is briefly undefined\n// mid-render has to fail quietly, and the catch below stays. A ReferenceError\n// is the one failure worth a word: `with` resolves a name against the store and\n// then globalThis, so a name that resolves nowhere is declared nowhere - a\n// typo, a dropped prop, or the trap this was written for, a top-level\n// `function` declaration, which transformSetupScript leaves as an ordinary\n// lexical binding instead of a store property\n//\n// It is reported late rather than where it throws, because \"declared nowhere\"\n// is not yet decidable at that moment: a factory script assigns its bindings to\n// the store when it returns, so an async factory renders its whole template\n// before any of its names exist. Reporting waits until no script is still\n// running (pendingScripts), and then asks whether the name resolves *now*.\n//\n// The re-check is `name in scope` rather than a re-evaluation, because\n// re-evaluating is not pure: `@click=\"count++ + missing\"` increments before it\n// throws, and running it again to see if it still throws would increment twice\n// and notify. `in` walks the same scope chain (:each scopes are\n// Object.create(scope), :with is a proxy over it) and evaluates nothing\nconst MISSING_NAME_RE = /^(?:([\\w$]+) is not defined|Can't find variable: ([\\w$]+))/\n\n// the queue holds live scopes, so it is capped: a script that never settles\n// would otherwise let it grow for the life of the page\nconst MAX_PENDING_REPORTS = 100\n\ntype PendingReport = { name: string; expr: string; scope: Record<string, any> }\n\nconst pendingReports = new Map<string, PendingReport>()\nconst reportedExprErrors = new Set<string>()\nlet pendingScripts = 0\nlet flushScheduled = false\n\n// everything else an expression can throw - overwhelmingly a member access on\n// an undefined value, `{{ game.is.loaded }}` over a game with no `is`. Unlike a\n// missing name it needs no deferral and gets none: the engine already caught a\n// real exception and wrote the message, so there is nothing left to decide and\n// it is reported where it throws, as an error rather than a warning.\n//\n// That means a value still on its way is reported too - `{{ user.name }}` over\n// a user that a fetch will fill renders empty and says so, once. It is a\n// deliberate trade against the silence it replaces, which hid a render that was\n// actively wrong (a thrown `:disabled` is falsy, so the button rendered\n// *enabled*). The fix is the one the message names: `user?.name`, or `:if`.\n//\n// Deduped by expression text alone. A `:each` over 1000 rows throws 1000 times\n// per render and the Set is what keeps that to one line; keying finer - by\n// message too, as the missing-name queue does - would let one broken path\n// report once per distinct message. There is no queue behind it because there\n// is nothing to re-check, and so nothing that could retain a live scope\nconst reportedFailedExprs = new Set<string>()\n\nconst flushExprReports = () => {\n  flushScheduled = false\n  if (pendingScripts > 0) return // a script started meanwhile; its release re-schedules\n  pendingReports.forEach(({ name, expr, scope }, key) => {\n    if (name in scope) return // it arrived late - a factory's bindings, a prop\n    reportedExprErrors.add(key)\n    console.warn(\n      `jq79: ${name} is not defined - evaluating \"${expr}\". Template expressions ` +\n      `resolve against the component store: a top-level let/var/const in a :setup ` +\n      `script, a declared prop, or a global. Note a \"function name() {}\" declaration ` +\n      `is not on the store - write \"const name = () => {}\".`\n    )\n  })\n  pendingReports.clear()\n}\n\nconst scheduleExprReportFlush = () => {\n  if (flushScheduled || pendingScripts > 0 || !pendingReports.size) return\n  flushScheduled = true\n  queueMicrotask(flushExprReports)\n}\n\n// scripts run before the template renders, so the counter is already up when\n// the first evaluation fails. Both script modes settle through a promise;\n// the factory's has to cover the merge, not just the module body\nconst trackScript = (settled: Promise<unknown>) => {\n  pendingScripts++\n  const release = () => {\n    pendingScripts--\n    scheduleExprReportFlush()\n  }\n  settled.then(release, release)\n}\n\n// console.error, not warn: a name that resolves nowhere is a warning because\n// the runtime can only say the name is absent, while this one caught a real\n// exception - it has a message the engine wrote, and the expression rendered as\n// nothing instead of doing what it says\nconst reportFailedExpr = (expr: string, error: unknown) => {\n  if (reportedFailedExprs.has(expr)) return\n  reportedFailedExprs.add(expr)\n  const message = (error as Error)?.message || String(error)\n  console.error(\n    `jq79: ${message} - evaluating \"${expr}\". The expression rendered as nothing. ` +\n    `If the value arrives later, guard it - \"a?.b\", or :if on the element.`\n  )\n}\n\nconst reportExprError = (expr: string, scope: Record<string, any>, error: unknown) => {\n  if (!(error instanceof ReferenceError)) return reportFailedExpr(expr, error)\n  const match = MISSING_NAME_RE.exec(error.message)\n  const name = match?.[1] ?? match?.[2]\n  if (!name) return // an engine whose wording we don't know: stay quiet, as before\n  // keyed on name and expression, not on the expression alone, so two missing\n  // names in one expression stay distinguishable - and so a :each of 1000 items\n  // enqueues one entry rather than 1000\n  const key = `${name}|${expr}`\n  if (reportedExprErrors.has(key) || pendingReports.has(key)) return\n  if (pendingReports.size >= MAX_PENDING_REPORTS) return\n  pendingReports.set(key, { name, expr, scope })\n  scheduleExprReportFlush()\n}\n\nconst runExpr = (expr: string, scope: Record<string, any>, extras?: Record<string, any>): any => {\n  const fn = compileExpr(expr, extras ? Object.keys(extras) : [])\n  if (!fn) return undefined // a syntax error: compileExpr cached the failure, and it stays undefined\n  return fn(scope, ...(extras ? Object.values(extras) : []))\n}\n\nconst evalExpr = (expr: string, scope: Record<string, any>, extras?: Record<string, any>): any => {\n  try {\n    return runExpr(expr, scope, extras)\n  } catch (error) {\n    reportExprError(expr, scope, error)\n    return undefined\n  }\n}\n\n// the same evaluation for an @event attribute, which swallows far less. Every\n// word of the reason evalExpr catches is about rendering: an expression is\n// re-evaluated per effect run, per interpolation, per :each item, so a value\n// that is briefly undefined mid-render has to render empty rather than tear the\n// render down. A handler runs in an event listener - not in an effect, once,\n// when the user clicked - so there is no transient failure to absorb, only a\n// bug to report, and an exception belongs in the console with its stack. That\n// is what `@click=\"save\"` has always done (the call happens outside the try,\n// on the returned function); this is what makes `@click=\"save()\"` and\n// `@click=\"count++\"` behave the same rather than the other way round.\n//\n// ReferenceError is the exception, for the reason it always is: it is not yet\n// decidable at throw time. A factory assigns its names to the store when it\n// returns, so a click while one is still in flight throws for a name that is\n// about to exist - reportExprError re-checks after the scripts settle and stays\n// quiet if it arrived, which throwing here would replace with a false alarm\nconst evalHandler = (expr: string, scope: Record<string, any>, extras: Record<string, any>): any => {\n  try {\n    return runExpr(expr, scope, extras)\n  } catch (error) {\n    if (!(error instanceof ReferenceError)) throw error\n    reportExprError(expr, scope, error)\n    return undefined\n  }\n}\n\n// [\\s\\S] rather than `.` so an expression can span lines, like the ones in\n// directive attributes (which reach evalExpr wrapped in parens either way)\nconst interpolate = (template: string, scope: Record<string, any>): string =>\n  template.replace(/{{\\s*([\\s\\S]+?)\\s*}}/g, (_, expr) => evalExpr(expr, scope) ?? \"\")\n\n\nconst CONTROL_ATTRS = new Set([\":attrs\", \":class\", \":value\", \":checked\", \":selected\", \":if\", \":elseif\", \":else\", \":each\", \":key\", \":with\", \":text\", \":html\", \":html.allowed\", \":props\"])\n\n// a control attribute is one the static-attr loop and nested-component prop\n// collection must skip. The set holds the fixed names; `:class.<name>` (the\n// single-flag shorthand) and `:props.<n>` (one spread among several) are\n// open-ended, so they're matched by prefix - they can't be enumerated into the set\nconst isControlAttr = (attr: string): boolean =>\n  CONTROL_ATTRS.has(attr) || attr.startsWith(\":class.\") || attr.startsWith(\":props.\") ||\n  attr === \":slot\" || attr.startsWith(\":slot.\")\n// `item in items`, `item, i in items`, `(value, key) in props` - the second\n// binding is the array index or the object key, parens optional (Vue-style).\n// The list expression can span lines, so it matches [\\s\\S] rather than `.`\nconst EACH_PATTERN = /^\\s*\\(?\\s*(\\w+)\\s*(?:,\\s*(\\w+))?\\s*\\)?\\s+in\\s+([\\s\\S]+)$/\n\ntype ConditionalBranch = { expr?: string; node: TemplateNode }\n\n\n// @event attributes: @click=\"onClick\", @submit.prevent=\"$event => onSubmit($event)\",\n// or an inline statement like @click=\"count = count + 1\". The expression is\n// evaluated (with `$event` in scope) on every event; if it yields a function,\n// that function is then invoked with the event - so both a handler reference\n// and an inline arrow/statement work. Modifiers after dots: .prevent .stop\n// .self (runtime guards) and .once .capture (addEventListener options)\nconst bindEvent = (el: Element, attr: string, expr: string, scope: Record<string, any>) => {\n  const [name, ...modifiers] = attr.slice(1).split(\".\")\n  const mods = new Set(modifiers)\n\n  el.addEventListener(name, event => {\n    if (mods.has(\"self\") && event.target !== el) return\n    if (mods.has(\"prevent\")) event.preventDefault()\n    if (mods.has(\"stop\")) event.stopPropagation()\n\n    const handler = evalHandler(expr, scope, { $event: event })\n    if (typeof handler === \"function\") handler.call(el, event)\n  }, { once: mods.has(\"once\"), capture: mods.has(\"capture\") })\n}\n\n// @event on a component tag: the tag renders as comment anchors, so there is\n// no element to listen on - the attribute subscribes to the child instance's\n// $emit channel (instance.on) instead, which survives the child's re-renders\n// and works detached. Native DOM events from the child's inner DOM never\n// arrive here: they bubble past the anchors to shared ancestors (a listener\n// on a wrapping element hears those); a child that wants its native event\n// heard on its tag re-emits it. .prevent flips the child's $emit() return to\n// false, .stop keeps the emit off the DOM dispatch, .once unsubscribes after\n// one call; .self and .capture have no meaning on this channel and are ignored\nconst wireTagEvent = (instance: Component79, attr: string, expr: string, scope: Record<string, any>) => {\n  const [name, ...modifiers] = attr.slice(1).split(\".\")\n  const mods = new Set(modifiers)\n\n  const listener = (event: CustomEvent) => {\n    if (mods.has(\"prevent\")) event.preventDefault()\n    if (mods.has(\"stop\")) event.stopPropagation()\n    if (mods.has(\"once\")) instance.off(name, listener)\n\n    // untracked, so a tag handler behaves like an element handler no matter\n    // when the emit fires: an element handler never runs inside an effect,\n    // but $emit can (a $: that emits, a setup-script emit inside the parent's\n    // creation effect), and the handler's reads would land in that effect's\n    // deps. Today that is contained - cross-store deps are never notified,\n    // and the creation effect's definition guard no-ops a spurious wake - but\n    // \"what a handler reads is nobody's dependency\" shouldn't hinge on either\n    untracked(() => {\n      const handler = evalHandler(expr, scope, { $event: event })\n      if (typeof handler === \"function\") handler(event)\n    })\n  }\n  instance.on(name, listener)\n}\n\nconst kebabToCamel = (name: string) => name.replace(/-(\\w)/g, (_, c: string) => c.toUpperCase())\n\n// the inverse, used only by the pre-parse name rewrite (see expandNameCase):\n// uppercase ASCII letters only, never digits - `:props.0` is a generated\n// attribute name and splitting on digits would mangle it. Round-trips through\n// kebabToCamel, acronyms included: userID -> user-i-d -> userID\nconst camelToKebab = (name: string) => name.replace(/[A-Z]/g, c => `-${c.toLowerCase()}`)\n\n// the stable boundaries of a rendered chunk. An element is its own handle, but\n// a fragment (a nested component: two anchors with the instance's DOM between\n// them) empties itself into the parent on insertion - after that its identity\n// answers nothing, and what stays put are its first and last children. Callers\n// that reposition or remove a chunk later (:each entries, :if branches) must\n// capture its bounds *before* inserting it and work on the range\ntype NodeRange = { first: Node; last: Node }\n\nconst boundsOf = (node: Node): NodeRange =>\n  node instanceof DocumentFragment\n    ? { first: node.firstChild!, last: node.lastChild! }\n    : { first: node, last: node }\n\n// removes [first..last] inclusive - the range's content is dynamic (a nested\n// component's DOM comes and goes between its anchors), so it walks siblings\n// rather than assuming any particular nodes in between\nconst removeRange = ({ first, last }: NodeRange) => {\n  for (let node: Node | null = first; node; ) {\n    const next: Node | null = node === last ? null : node.nextSibling\n    node.parentNode?.removeChild(node)\n    node = next\n  }\n}\n\n// moves [first..last] inclusive so the range starts right after `prev`\nconst moveRangeAfter = ({ first, last }: NodeRange, prev: Node) => {\n  const ref = prev.nextSibling\n  for (let node: Node | null = first; node; ) {\n    const next: Node | null = node === last ? null : node.nextSibling\n    prev.parentNode!.insertBefore(node, ref)\n    node = next\n  }\n}\n\n// finds the scope variable a template tag refers to. HTML parsing lowercases\n// tag names, so <NestedComponent> arrives as \"nestedcomponent\" and matching is\n// case-insensitive with dashes stripped (<nested-component> works too). Only\n// PascalCase scope keys participate, so ordinary variables named like real\n// elements (title, code, ...) never hijack them\nconst findComponentKey = (scope: Record<string, any>, tag: string): string | null => {\n  const normalized = tag.replace(/-/g, \"\").toLowerCase()\n  for (let obj: any = scope; obj && obj !== Object.prototype; obj = Object.getPrototypeOf(obj)) {\n    for (const key of Object.keys(obj)) {\n      if (/^[A-Z]/.test(key) && key.replace(/-/g, \"\").toLowerCase() === normalized) return key\n    }\n  }\n  return null\n}\n\n// every name a tag *could* have resolved to, walking the same chain\n// findComponentKey does. Deduped and sorted, because the chain can hold one\n// name twice (a prop shadowing a sibling) and the order it comes out in is the\n// prototype's, which means nothing to a reader scanning for their typo\nconst componentsInScope = (scope: Record<string, any>): string[] => {\n  const names = new Set<string>()\n  for (let obj: any = scope; obj && obj !== Object.prototype; obj = Object.getPrototypeOf(obj)) {\n    for (const key of Object.keys(obj)) if (/^[A-Z]/.test(key)) names.add(key)\n  }\n  return [...names].sort()\n}\n\n// a tag whose name resolves to no component, once nothing can still supply one.\n// The error names what *is* in scope: the mistake is nearly always a typo or a\n// missing import, and both are one glance from the list. \"(none)\" is its own\n// answer - it says the component has no components at all, which points at the\n// import rather than at the spelling\nconst unresolvedComponent = (tag: string, scope: Record<string, any>): Error => {\n  const names = componentsInScope(scope)\n  return new Error(\n    `jq79: <${tag}> is not defined - no component of that name is in scope, and nothing renders here. ` +\n    `Import it in a :setup script, declare it as a prop, or add a <template name=\"${tag}\"> to this file. ` +\n    `In scope: ${names.length ? names.join(\", \") : \"(none)\"}.`\n  )\n}\n\n// how deep a component may nest inside itself before the runtime calls it a\n// cycle. Deeper than any real tree, shallower than the JS stack: a truncated\n// render with an error on the console beats a stack overflow with none\nconst MAX_NESTING_DEPTH = 200\nlet nestingDepth = 0\n\n// ---------------------------------------------------------------------------\n// slots - content projection\n//\n// A component tag's children are content the child renders where it wrote a\n// <slot>. The dot marks the named variant on both sides, like :model.<name>\n// and :class.<name> already do:\n//\n//   <!-- Card.html -->        <!-- the parent -->\n//   <section>                 <Card>\n//     <header>                  <template :slot.header><h2>{{ t }}</h2></template>\n//       <slot.header>?</slot.header>\n//     </header>                 <p>{{ body }}</p>\n//   <slot />                  </Card>\n//   </section>\n//\n// Three rules decide everything below:\n//\n// 1. Content belongs to the parent - its AST, its scope, its effects, its\n//    scoped styles. The child decides *where* it goes and *whether* it goes,\n//    never what the names in it mean.\n// 2. Slot props are declared, not injected: `:slot=\"{ item }\"` on the usage\n//    site, for the same reason :each writes `item in rows`. Every bare name in\n//    the parent's file is introduced by the parent, so a `<slot :item>` the\n//    child adds later can't silently capture one.\n// 3. What isn't projected isn't rendered. No <slot>, or one behind a false\n//    :if, and the content's effects never exist.\n//\n// The content travels as a thunk, not as DOM: an instance is replaced (a\n// definition swap, a hot reload) and one <slot> may render many times, so a\n// pre-rendered fragment would leak effects and could only be inserted once\n// ---------------------------------------------------------------------------\n\n// renders one slot's content at the position the child put the <slot>: it is\n// handed the slot's props (lazy, so each read re-evaluates in the child's\n// scope), that position's scope and effect scope, and the style mode the\n// child renders under\ntype SlotRenderer = (\n  props: Record<string, () => any>,\n  slotScope: Record<string, any>,\n  fx: EffectScope,\n  shadow: boolean\n) => Node\n\ntype SlotMap = Record<string, SlotRenderer>\n\n// the content an instance was handed, by slot name. Symbol-keyed and\n// non-enumerable on the store's data, like UNFILLED_PROPS: it rides the scope\n// chain (so a <slot> inside an :each or a :with finds it) and never shows up\n// as data - not in Object.keys, not in a snapshot spread, not in the props a\n// nested component is handed\nconst SLOTS = Symbol(\"jq79.slots\")\n\n// <slot>, <slot.header-bar>: the hole and its name. Names arrive kebab-case\n// whichever way they were authored (the HTML parser lowercases tag names and\n// attribute modifiers alike, so expandNameCase normalizes camelCase to kebab\n// before parsing) and are camelCase where read - <slot.header-bar> and\n// <slot.headerBar> are :slot.header-bar is $slots.headerBar\nconst isSlotTag = (tag: string): boolean => tag === \"slot\" || tag.startsWith(\"slot.\")\n\nconst slotName = (suffix: string): string => (suffix ? kebabToCamel(suffix) : \"default\")\n\n// the content of one slot, as written at the usage site\ntype SlotContent = { nodes: (TemplateNode | string)[]; binder?: string }\n\n// the :slot attribute of a <template>, if it carries one\nconst slotAttrOf = (node: TemplateNode): string | undefined =>\n  Object.keys(node.attrs).find(attr => attr === \":slot\" || attr.startsWith(\":slot.\"))\n\nconst slotAttrName = (name: string) => (name === \"default\" ? \":slot\" : `:slot.${name}`)\n\n// whitespace-only text between two <template :slot> blocks is the indentation\n// between them and nothing else - the same call renderNodes makes between the\n// branches of an :if chain. It is what decides whether a tag has default\n// content at all, which is what $slots.default answers\nconst isMeaningful = (node: TemplateNode | string): boolean => typeof node !== \"string\" || node.trim() !== \"\"\n\n// a component tag's children, partitioned by slot name: a direct\n// <template :slot.<name>> child fills that name, everything else is the\n// default slot's content. The attribute's value is the pattern the content\n// binds the slot's props to - on the tag itself for the default, since the\n// default content has no <template> of its own to carry it\nconst partitionSlots = (node: TemplateNode): Record<string, SlotContent> => {\n  const contents: Record<string, SlotContent> = {}\n  const loose: (TemplateNode | string)[] = []\n\n  node.children.forEach(child => {\n    const attr = typeof child === \"object\" && child.tag === \"template\" ? slotAttrOf(child) : undefined\n    if (typeof child === \"string\" || attr === undefined) {\n      loose.push(child)\n      return\n    }\n    const name = slotName(attr.slice(\":slot.\".length))\n    // first wins, like two <template name=\"X\"> in one file: a duplicate is a\n    // typo, and the fix is to delete one - not to guess which\n    if (name in contents) {\n      console.warn(`jq79: two <template ${slotAttrName(name)}> in <${node.tag}>; the second was ignored`)\n      return\n    }\n    contents[name] = { nodes: child.children, binder: child.attrs[attr] || undefined }\n  })\n\n  const hasLoose = loose.some(isMeaningful)\n  if (hasLoose && \"default\" in contents) {\n    console.warn(\n      `jq79: <${node.tag}> has both a <template :slot> and content outside it - ` +\n      \"the <template> is the default slot's content, and the rest was ignored\"\n    )\n  } else if (hasLoose) {\n    contents.default = { nodes: loose, binder: node.attrs[\":slot\"] || undefined }\n  }\n  return contents\n}\n\n// `:slot=\"{ item, index: i, total = 0 }\"` - the names the content binds the\n// slot's props to. The bindings are accessors, not values: each read\n// re-evaluates the child's expression, so an effect that reads `item` tracks\n// exactly what that expression touches, on every run (createWithScope's design)\nconst bindSlotProps = (scope: Record<string, any>, binder: string | undefined, props: Record<string, () => any>) => {\n  parsePropsPattern(binder)?.forEach(({ name, as, default: fallback }) => {\n    const local = as ?? name\n    Object.defineProperty(scope, local, {\n      enumerable: true,\n      configurable: true,\n      get: () => {\n        const value = props[name]?.()\n        return value === undefined && fallback !== undefined ? evalExpr(fallback, scope) : value\n      },\n      // a slot prop is the child's value: it arrives on every read and there\n      // is nowhere for a write to go. Silence would be worse - `with` swallows\n      // an assignment to a getter without a word\n      set: () => console.warn(`jq79: \"${local}\" is a slot prop - it comes from the component, so assigning to it does nothing`),\n    })\n  })\n}\n\n// a <template :slot> only fills a slot as a direct child of a component tag,\n// where the usage site takes it out of the children before they are ever\n// rendered (see partitionSlots). Anywhere else the position is a mistake, and\n// rendering the content in place - in the wrong scope, into a <template>\n// nobody clones - would be a strange way to say so. A comment rather than\n// nothing: an :if branch needs a node to hold on to (see boundsOf)\nconst misplacedSlotContent = (node: TemplateNode): Node => {\n  const attr = slotAttrOf(node)\n  console.warn(`jq79: <template ${attr}> fills a slot only as a direct child of a component tag; here it rendered nothing`)\n  return document.createComment(`misplaced ${attr}`)\n}\n\n// what a usage site hands its instance: every slot it filled, as the thunk\n// that renders it. Built once per site, and in one call - a component tag is\n// on the stack while its whole subtree renders below it (a component that\n// renders itself does this 200 deep), so the intermediates stay in here rather\n// than in the frame that waits\nconst buildSlots = (node: TemplateNode, scope: Record<string, any>): SlotMap | null => {\n  const contents = Object.entries(partitionSlots(node))\n  if (!contents.length) return null\n  const slots: SlotMap = {}\n  contents.forEach(([name, content]) => { slots[name] = makeSlotRenderer(content, scope) })\n  return slots\n}\n\n// the thunk one slot's content becomes: the usage site closes over its AST and\n// its scope, the child calls it wherever (and however many times) it renders\n// the matching <slot>\nconst makeSlotRenderer = (content: SlotContent, parentScope: Record<string, any>): SlotRenderer =>\n  (props, slotScope, fx, shadow) => {\n    // the parent's scope, plus the names the content declared for the slot's\n    // props (rule 1: what the content says is decided where it was written)\n    const scope: Record<string, any> = Object.create(parentScope)\n    bindSlotProps(scope, content.binder, props)\n    // this content reads the parent's store (its own names) and the child's\n    // (through the slot props), so every effect created anywhere inside it is\n    // registered with both - see ALSO_WAKEN_BY. Appended rather than assigned:\n    // content forwarded through a <slot> inside slot content is still woken by\n    // the store it came from\n    const inherited: Record<string, any>[] = (scope as any)[ALSO_WAKEN_BY] ?? []\n    Object.defineProperty(scope, ALSO_WAKEN_BY, { value: [...inherited, slotScope] })\n\n    const contentFx = createEffectScope(scope)\n    // rule 3: the <slot> is the content's lifetime. When the child's subtree at\n    // this position goes - an :if turning false, the instance being replaced,\n    // the whole child being destroyed - the content's effects go with it\n    fx.onDispose(() => contentFx.dispose())\n    return renderNodes(content.nodes, scope, contentFx, shadow)\n  }\n\n// <slot />, <slot.name>fallback</slot.name>: where the parent's content goes.\n// Unfilled, the slot renders its own children instead - in this component's\n// scope, since that content is this component's. Every attribute that isn't a\n// directive is a slot prop: `:item=\"item\"` evaluates here and reaches the\n// content under the name it declared, a plain attribute passes a literal\n// string, and there are no reserved names (the slot's own name is in the tag).\n// Bracketed by anchors like a nested component, so the chunk has stable bounds\n// even when it renders nothing (see boundsOf)\nconst renderSlot = (node: TemplateNode, scope: Record<string, any>, fx: EffectScope, shadow: boolean): Node => {\n  const name = slotName(node.tag.slice(\"slot.\".length))\n  const wrapper = document.createDocumentFragment()\n  const anchor = document.createComment(node.tag)\n  const endAnchor = document.createComment(`/${node.tag}`)\n  wrapper.append(anchor, endAnchor)\n\n  const render = (scope as any)[SLOTS]?.[name] as SlotRenderer | undefined\n  if (!render) {\n    wrapper.insertBefore(renderNodes(node.children, scope, fx, shadow), endAnchor)\n    return wrapper\n  }\n\n  const props: Record<string, () => any> = {}\n  Object.entries(node.attrs).forEach(([attr, value]) => {\n    // the scope stamp is the component's, not a prop; @events have no element\n    // to bind here; and a directive means what it means everywhere else -\n    // :if/:each/:with decide whether and how often this slot renders, so they\n    // are the renderer's, not the content's\n    if (attr === SCOPE_ATTR || isControlAttr(attr) || attr.startsWith(\"@\")) return\n    if (attr.startsWith(\":\")) {\n      const expr = value || attr.slice(1)\n      props[kebabToCamel(attr.slice(1))] = () => evalExpr(expr, scope)\n    } else {\n      props[kebabToCamel(attr)] = () => value\n    }\n  })\n\n  wrapper.insertBefore(render(props, scope, fx, shadow), endAnchor)\n  return wrapper\n}\n\n// <MyComponent :user :title=\"'str'\"></MyComponent> - renders a child\n// component instance at this position. Props: `:name=\"expr\"` evaluates expr\n// in the parent scope (`:name` alone is shorthand for `:name=\"name\"`), plain\n// attributes pass through as literal strings, and kebab-case prop names\n// become camelCase. Props stay live: a parent effect re-evaluates each\n// expression and writes it into the child's store. The component variable is\n// reactive too - while it's undefined (e.g. an `await import(...)` still in\n// flight) nothing renders, and the child appears when it resolves.\n// `shadow` is the parent's style mode, carried down the whole render: a child\n// of a shadow-rendered component renders inside that shadow root, so its\n// <style> has to go in there with it - document.head can't reach into a shadow\n// tree, and a style that never applies to its own component would still be\n// restyling the page around it\nconst renderNestedComponent = (key: string, node: TemplateNode, scope: Record<string, any>, fx: EffectScope, shadow: boolean): Node => {\n  // two anchors bracketing everything this usage site ever renders: the\n  // instance's DOM is dynamic (the definition can resolve late or be swapped),\n  // so a caller that needs to move or remove this chunk later can't hold any\n  // of it - it holds the anchors, which never move on their own (see boundsOf)\n  const anchor = document.createComment(key)\n  const endAnchor = document.createComment(`/${key}`)\n  const wrapper = document.createDocumentFragment()\n  wrapper.append(anchor, endAnchor)\n\n  // the tag's children, as content for the child's <slot>s. Built once per\n  // usage site (the AST doesn't change) and closed over the parent's scope\n  // here, so every instance this site ever renders is handed the same thunks\n  const slots = buildSlots(node, scope)\n\n  const props: Record<string, string> = {} // prop name -> expression in parent scope\n  const models: Record<string, string> = {} // model name -> assignable expression in parent scope\n  const events: Array<[string, string]> = [] // @attr (modifiers included) -> handler expression\n  // named props AND spreads in source order - what a :props merge folds over so\n  // precedence follows the JS object-spread rule (later wins). `name` absent\n  // marks a spread: the whole object's properties, not one binding\n  const sources: Array<{ name?: string; expr: string }> = []\n  let hasSpread = false\n  Object.entries(node.attrs).forEach(([attr, value]) => {\n    // the parent's scope stamp is stamped on every template element, this tag\n    // included - it's not a prop, and the child renders under its own scope\n    if (attr === SCOPE_ATTR) return\n    if (attr === \":props\" || attr.startsWith(\":props.\")) {\n      // :props=\"obj\" spreads obj's own properties as props; :props.<n> is one\n      // spread among several (the `...obj` sugar rewrites to it - see\n      // expandPropsSpread), the suffix only keeping the attribute names distinct\n      hasSpread = true\n      sources.push({ expr: value })\n      return\n    }\n    if (isControlAttr(attr)) return\n    if (attr.startsWith(\"@\")) {\n      events.push([attr, value])\n    } else if (attr === \":model\" || attr.startsWith(\":model.\")) {\n      // :model[.name]=\"expr\" - two-way: a prop down plus a writeback listener\n      // (wired below, once the instance exists). The modifier arrives\n      // kebab-case whichever way it was authored (expandNameCase rewrote any\n      // camelCase before parsing); the bare :model binds the name \"default\"\n      const name = attr === \":model\" ? \"default\" : kebabToCamel(attr.slice(\":model.\".length))\n      models[name] = value || (attr === \":model\" ? \"model\" : name)\n    } else if (attr.startsWith(\":\")) {\n      const name = kebabToCamel(attr.slice(1))\n      props[name] = value || name\n      sources.push({ name, expr: value || name })\n    } else {\n      const name = kebabToCamel(attr)\n      const expr = JSON.stringify(value)\n      props[name] = expr\n      sources.push({ name, expr })\n    }\n  })\n\n  // each model is also a prop down: the child reads the value under the\n  // model's name - `model` for the default, because a prop named `default`\n  // could never be read from a child expression (reserved word). Without the\n  // prop this isn't two-way, it's upward collection: a parent reset or an\n  // initial value would never reach the child\n  const modelAttr = (name: string) => (name === \"default\" ? \":model\" : `:model.${name}`)\n  const modelProp = (name: string) => (name === \"default\" ? \"model\" : name)\n  // the newline keeps `= $value` out of a trailing line comment in the\n  // expression (:model=\"uname // the username\") - glued on the same line,\n  // the assignment would vanish into the comment and compile as a bare read,\n  // dropping every update without a word\n  const assignment = (expr: string) => `${expr}\\n= $value`\n  // the models whose expression will never take an update, decided here rather\n  // than at update time: an assignment that landed and one that was dropped\n  // both evaluate to the value assigned, so the result can't tell them apart -\n  // which is what $updateModel's return has to report\n  const unassignable = new Set<string>()\n  Object.entries(models).forEach(([name, expr]) => {\n    const prop = modelProp(name)\n    if (props[prop] !== undefined) {\n      console.warn(`jq79: <${node.tag}> binds prop \"${prop}\" through both :${prop} and ${modelAttr(name)} - ${modelAttr(name)} wins`)\n    }\n    props[prop] = expr\n    // an expression that can't be an assignment target is a wiring mistake -\n    // say so now, not on the first update that silently goes nowhere\n    if (compileExpr(assignment(expr), [\"$value\"]) === null) {\n      unassignable.add(name)\n      console.warn(`jq79: ${modelAttr(name)}=\"${expr}\" is not assignable - updates from <${node.tag}> will be dropped`)\n    }\n  })\n\n  // the full prop set the child gets, resolved in source order: each named prop\n  // sets one key, each spread merges an object's own properties, later sources\n  // overwriting earlier (the JS object-spread rule). :model bindings apply last,\n  // so they win - the same precedence the collision warning above promises. A\n  // spread expression that isn't an object contributes nothing (fail closed,\n  // like :with), so an `await`-pending object spreads once it resolves\n  const resolveProps = (): Record<string, any> => {\n    const out: Record<string, any> = {}\n    sources.forEach(({ name, expr }) => {\n      if (name !== undefined) out[name] = evalExpr(expr, scope)\n      else {\n        const obj = evalExpr(expr, scope)\n        if (obj !== null && typeof obj === \"object\") Object.assign(out, obj)\n      }\n    })\n    Object.entries(models).forEach(([name, expr]) => { out[modelProp(name)] = evalExpr(expr, scope) })\n    return out\n  }\n\n  let current: Component79 | null = null\n  let currentDef: Component79 | null = null\n  let childFx: EffectScope | null = null\n\n  // a usage site that resolves to no component renders nothing, which is\n  // deliberate - `undefined` while an `await import(...)` is in flight has to\n  // wait quietly, and the child appears when it lands. Two cases can never\n  // resolve, though, and both are wiring mistakes worth naming: a value that\n  // isn't a component (and so will never become one by waiting), and a name\n  // the component declared as a prop that the parent passed nothing for. Once\n  // each, per usage site: an effect re-runs\n  const reported = new Set<string>()\n  const reportUnresolved = (value: any) => {\n    if (value === undefined || value === null) {\n      const unfilled: Set<string> | undefined = (scope as any)[UNFILLED_PROPS]\n      if (!unfilled?.has(key) || reported.has(\"unfilled\")) return\n      reported.add(\"unfilled\")\n      console.error(\n        `jq79: <${node.tag}> is declared as a prop and the parent passed nothing - nothing renders here. ` +\n        `Pass it (:${key}=\"…\"), or drop it from the signature to use the one declared in this file.`\n      )\n      return\n    }\n    if (reported.has(\"type\")) return\n    reported.add(\"type\")\n    console.error(`jq79: <${node.tag}> is ${typeof value}, not a component - nothing renders here`)\n  }\n\n  fx.effect(() => {\n    const value = evalExpr(key, scope)\n    const nextDef = value instanceof Component79 ? value : null\n    if (!nextDef) reportUnresolved(value)\n    if (nextDef === currentDef) return\n\n    childFx?.dispose()\n    childFx = null\n    current?.destroy() // detaches its marker range, removing the child's DOM\n    current = null\n    currentDef = nextDef\n    if (!nextDef) return\n\n    // a fresh instance per usage site: the definition's parsed parts (and\n    // pre-resolved modules) are shared, but store/effects/DOM are per instance\n    const instance = new Component79({\n      template: nextDef.template,\n      scripts: nextDef.scripts,\n      styles: nextDef.styles,\n      modules: nextDef.modules,\n      filename: nextDef.filename,\n      // its file's other components, and which of them it is: without the\n      // first a child rendered here loses the siblings its definition could\n      // see, and without the second hot reload can't tell it what it is\n      siblings: nextDef.siblings,\n      name: nextDef.name,\n    })\n    // the content this site wrote inside the tag, before the first render: a\n    // <slot> is resolved while rendering, so the map has to be there by then\n    if (slots) instance.slots = slots\n    // the writeback half of :model - the function the child's $updateModel\n    // calls, handed over before the first render. Not an event: nothing about\n    // a parent-child assignment wants a CustomEvent bubbling through the page\n    // on every keystroke, and a direct call has no payload shape to get wrong.\n    // The name is normalized like the attribute was (kebab->camel; absent\n    // means the default model), and a name nothing binds warns: a typo must\n    // not be an input that types into the void\n    if (Object.keys(models).length) {\n      // each mistake is warned once per instance, not once per keystroke: an\n      // input updating a typo'd name would otherwise flood the console on\n      // every character typed into it\n      const warned = new Set<string>()\n      instance.modelWriteback = (rawName, value) => {\n        const name = rawName == null ? \"default\" : kebabToCamel(String(rawName))\n        const expr = models[name]\n        if (expr === undefined) {\n          if (!warned.has(name)) {\n            warned.add(name)\n            console.warn(`jq79: <${node.tag}> has no ${modelAttr(name)} - bound: ${Object.keys(models).map(modelAttr).join(\", \")}`)\n          }\n          return false\n        }\n        if (unassignable.has(name)) return false // already warned, at wiring time\n        // untracked, like the tag handlers: a child updating from its setup\n        // script runs inside the parent's *creation* effect, and the reads a\n        // path assignment makes (`user` in `user.name = $value`) would land\n        // in its deps - donating that effect one wasted (guard-stopped) wake\n        // per later write. An imperative writeback is nobody's dependency\n        untracked(() => evalExpr(assignment(expr), scope, { $value: value }))\n        return true\n      }\n    }\n\n    // @event on the tag listens to this instance's $emit channel (and only\n    // this instance's - a grandchild's emit arrives here solely as an\n    // explicit re-emit)\n    events.forEach(([attr, expr]) => wireTagEvent(instance, attr, expr, scope))\n\n    // what this component actually takes, decided by its signature. Applied to\n    // every path that writes a prop - the seed here and both sync paths below -\n    // or an undeclared name would be filtered on the first render and reappear\n    // on the next update\n    const declared = declaredPropSet(instance.scripts)\n    warnUndeclared(node, key, Object.keys(props), declared)\n    const seed = pickDeclared(untracked(resolveProps), declared)\n    // mounting into a fragment attaches no shadow root of its own: a\n    // shadow-rendered child keeps its <style> elements inline, next to the DOM\n    // they style, and the parent's shadow root is what scopes both\n    const holder = document.createDocumentFragment()\n    // rendering a child happens on this same stack, so a component that\n    // renders itself recurses as deep as its data does - and a cycle in that\n    // data would recurse until the JS stack gave out, ~900 identical frames\n    // naming nothing. Cut and named instead, exactly like the effect runner\n    // cuts an effect that wakes itself\n    if (nestingDepth >= MAX_NESTING_DEPTH) {\n      console.error(\n        `jq79: <${node.tag}> is ${MAX_NESTING_DEPTH} levels deep inside itself; giving up here. ` +\n        \"A component that renders itself stops when its data stops - is there a cycle in it?\"\n      )\n      return\n    }\n    nestingDepth++\n    try {\n      ;(shadow ? instance.renderShadow(seed) : instance.render(seed)).mount(holder)\n    } finally {\n      nestingDepth--\n    }\n    endAnchor.parentNode!.insertBefore(holder, endAnchor)\n\n    const syncFx = createEffectScope(scope)\n    // without a spread the prop set is fixed and known: one effect per prop, so\n    // a change to one prop re-syncs only that prop. A spread's key set is\n    // dynamic and its precedence is positional, so it can't be resolved a key at\n    // a time across independent effects (whichever re-ran last would win) - one\n    // effect re-merges everything in order and writes the diff, clearing keys a\n    // spread has dropped since last run. Named props are always in the merge, so\n    // they're never cleared; the extra cost is confined to spread-using tags\n    if (hasSpread) {\n      let written: string[] = []\n      syncFx.effect(() => {\n        const next = pickDeclared(resolveProps(), declared)\n        const nextKeys = Object.keys(next)\n        written.forEach(key => { if (!(key in next)) (instance.data as Record<string, any>)[key] = undefined })\n        nextKeys.forEach(key => { (instance.data as Record<string, any>)[key] = next[key] })\n        written = nextKeys\n      })\n    } else {\n      Object.entries(props).forEach(([name, expr]) => {\n        if (declared !== null && !declared.has(name)) return\n        syncFx.effect(() => { (instance.data as Record<string, any>)[name] = evalExpr(expr, scope) })\n      })\n    }\n\n    childFx = syncFx\n    current = instance\n  })\n\n  fx.onDispose(() => {\n    childFx?.dispose()\n    current?.destroy()\n  })\n\n  return wrapper\n}\n\n// :with=\"expr\" narrows the scope for an element and its subtree: names\n// resolve against the expression's value first, then fall back to the outer\n// scope. The value is re-evaluated lazily on every name lookup (never\n// snapshotted), so an effect reading through this proxy tracks both the\n// expression's own dependencies and the property it reads - replacing the\n// object or mutating one of its properties re-renders exactly the dependents,\n// without rebuilding the subtree. Assignments to names the object owns write\n// through to it (reactively, if it came from a store); everything else\n// behaves as if the :with weren't there\nconst createWithScope = (expr: string, scope: Record<string, any>): Record<string, any> => {\n  const source = (): Record<string, any> | null => {\n    const value = evalExpr(expr, scope)\n    return value !== null && typeof value === \"object\" ? value : null\n  }\n  return new Proxy(scope, {\n    has(target, key) {\n      const obj = source()\n      return (obj !== null && Reflect.has(obj, key)) || Reflect.has(target, key)\n    },\n    get(target, key) {\n      const obj = source()\n      if (obj !== null && Reflect.has(obj, key)) return obj[key as string]\n      return Reflect.get(target, key)\n    },\n    set(target, key, value) {\n      const obj = source()\n      if (obj !== null && Reflect.has(obj, key)) {\n        obj[key as string] = value\n        return true\n      }\n      return Reflect.set(target, key, value)\n    },\n  })\n}\n\n// what :class accepts, flattened to single class tokens: a string of\n// space-separated names, an array (entries normalized recursively), or an\n// object whose truthy-valued keys are the names (a key may itself hold\n// several). Everything else - null, false, numbers - contributes nothing, so\n// `cond && 'active'` reads naturally. The object form reads each value, so a\n// store-backed flag is tracked per key\nconst classNames = (value: any): string[] => {\n  if (typeof value === \"string\") return value.split(/\\s+/).filter(Boolean)\n  if (Array.isArray(value)) return value.flatMap(classNames)\n  if (value !== null && typeof value === \"object\")\n    return Object.entries(value).flatMap(([name, on]) => (on ? classNames(name) : []))\n  return []\n}\n\n// what :html.allowed accepts, normalized to an AllowUrl predicate: host\n// patterns (a comma-separated string or an array - see allowedHosts in\n// ./dom) or a function (url: URL, tag, attr) => boolean. Anything else -\n// including a policy expression that evaluates to undefined - denies every\n// destination: the attribute declares the intent to restrict, so a broken\n// policy fails closed, and so does a predicate that throws\nconst normalizeAllowUrl = (policy: any): AllowUrl => {\n  if (typeof policy === \"function\") {\n    return (url, tag, attr) => {\n      try {\n        return !!policy(url, tag, attr)\n      } catch {\n        return false\n      }\n    }\n  }\n  if (typeof policy === \"string\" || Array.isArray(policy)) return allowedHosts(policy)\n  return () => false\n}\n\n// HTML's boolean attributes, verbatim from the spec's list. Presence is the\n// whole message for these: `disabled=\"false\"` and `disabled=\"0\"` both disable,\n// so the value they carry is noise. This is a table of a fact, not of a jq79\n// convention - nobody in this repo decides what belongs in it, which is what\n// earns it a place in a codebase that otherwise has no name tables\nconst BOOLEAN_ATTRS = new Set([\n  \"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"controls\",\n  \"default\", \"defer\", \"disabled\", \"formnovalidate\", \"inert\", \"ismap\",\n  \"itemscope\", \"loop\", \"multiple\", \"muted\", \"nomodule\", \"novalidate\", \"open\",\n  \"playsinline\", \"readonly\", \"required\", \"reversed\", \"selected\",\n])\n\n// the one value rule, shared by `:attr=\"expr\"` and `:attrs` so the two forms\n// can never disagree:\n//\n// - a boolean attribute is removed by ANY falsy value and set to \"\" when\n//   truthy, so `:disabled=\"items.length\"` enables the button on an empty list\n//   (with `value !== false` as the only test, 0 set the attribute and disabled\n//   it - the trap renderComponent.test.ts used to pin);\n// - every other attribute is removed only by null/undefined, so `false`, `0`\n//   and `\"\"` are written. `aria-expanded=\"false\"` and a `data-` flag mean\n//   something that absent cannot say.\n//\n// Asking the DOM which family a name belongs to (`typeof el[name] ===\n// \"boolean\"`) is deliberately not what this does: jsdom and Chrome disagree on\n// `autofocus` and every `aria-*`, so the tests would pin a semantics the\n// browser doesn't have - and `readonly`/`novalidate`/`ismap` reflect under\n// camelCase property names no kebab->camel pass can produce, failing toward\n// `readonly=\"false\"`, which is read-only\nconst applyAttr = (el: Element, name: string, value: any) => {\n  const boolean = BOOLEAN_ATTRS.has(name)\n  if (boolean ? !value : value == null) el.removeAttribute(name)\n  else el.setAttribute(name, boolean ? \"\" : String(value))\n}\n\n// renders a single element node: static attrs, @event listeners, a reactive\n// :attrs object, and its content - :text/:html override the element's own\n// children with a reactive textContent/innerHTML, otherwise children render\n// normally. :if/:elseif/:else/:each are handled by renderNodes, which decides\n// *whether*/*how many times* a node is rendered before calling this. Tags\n// matching a PascalCase scope variable render as nested components instead\nconst renderNode = (node: TemplateNode, outerScope: Record<string, any>, fx: EffectScope, shadow: boolean): Node => {\n  // :with applies to the element's own bindings (@events, :attrs) and its\n  // whole subtree. On a :each element the item scope is already in place, so\n  // :with=\"item\" works\n  const withExpr = node.attrs[\":with\"]\n  const scope = withExpr !== undefined ? createWithScope(withExpr, outerScope) : outerScope\n\n  // before the component-key scan, so <slot> is <slot> even in a file that\n  // happens to have a component named Slot in scope: the tag is the library's\n  // now, and a name that resolved it away would be a very quiet surprise\n  if (isSlotTag(node.tag)) return renderSlot(node, scope, fx, shadow)\n  if (node.tag === \"template\" && slotAttrOf(node) !== undefined) return misplacedSlotContent(node)\n\n  const componentKey = findComponentKey(scope, node.tag)\n  if (componentKey) return renderNestedComponent(componentKey, node, scope, fx, shadow)\n\n  const el = document.createElement(node.tag)\n\n  // <UserCrad /> - written as a component (node.component), resolving to no\n  // component, and not an element either. Nothing else on the page can supply\n  // the name once every script has settled, so this renders no markup, no\n  // styles, no children and no script, forever, and says so by throwing rather\n  // than leaving a hole where a region of the page was meant to be.\n  //\n  // All three conditions carry weight. Without the capitalization <lable> and\n  // <svg> would be fatal (createElement builds SVG names in the HTML namespace,\n  // so an <svg> is an HTMLUnknownElement too); without the element check <DIV>\n  // would be, though it renders a perfectly good div; and without the pending\n  // count a factory that awaits $mounted() before returning its components\n  // could never render one, which is exactly what the watcher below is for.\n  //\n  // An *absent* count is a fourth case, and it is not zero: renderComponent()\n  // renders a template against a store somebody else owns and assembles, so\n  // nothing there has finished and nothing says a key can't still be written\n  // in. The claim being tested is a component's claim about its own scripts,\n  // and where none was made the tag waits for the upgrade, as it always has.\n  //\n  // Written without a local for the count because renderNode is on the stack\n  // for the whole of the subtree below it, so a slot here is a slot per level\n  // of a component nested inside itself - see renderWith\n  if (node.component && el instanceof HTMLUnknownElement && ((scope as any)[PENDING_SCRIPTS] as PendingScripts | undefined)?.count === 0) {\n    throw unresolvedComponent(node.component, scope)\n  }\n\n  // a tag that isn't standard HTML but has no matching scope key *yet* may be\n  // a component that arrives later (e.g. an async factory script exposing an\n  // imported component after `await`). Watch for the key: the effect tracks\n  // no deps, so it only re-runs on the store's new-key sweep, and swaps the\n  // placeholder element for the component exactly once\n  // dashes included, because findComponentKey matches them case-insensitively\n  // with dashes stripped: <drop-area> resolves DropArea, so a dashed tag is a\n  // possible component too, not only a custom element\n  const mayUpgrade = el instanceof HTMLUnknownElement || node.tag.includes(\"-\")\n  if (mayUpgrade) {\n    let upgraded = false\n    fx.effect(() => {\n      if (upgraded) return\n      const key = findComponentKey(scope, node.tag)\n      if (!key) return\n      upgraded = true\n      const replacement = renderNestedComponent(key, node, scope, fx, shadow)\n      // whoever tears this subtree down holds `el`, which the swap detaches -\n      // so the component's anchors must remove themselves when the scope goes\n      const range = boundsOf(replacement)\n      fx.onDispose(() => removeRange(range))\n      el.replaceWith(replacement)\n    })\n  }\n\n  Object.entries(node.attrs).forEach(([key, value]) => {\n    if (key.startsWith(\"@\")) bindEvent(el, key, value, scope)\n    else if (key === \":model\" || key.startsWith(\":model.\")) {\n      // :model binds component tags only (see TODOS/2026-07-15.model-directive.md;\n      // the native-element form is parked there). Warn on a real element, but\n      // not on a tag that may still upgrade into a component - the upgrade\n      // re-renders through renderNestedComponent, models and all\n      if (!mayUpgrade) {\n        console.warn(`jq79: ${key} on <${node.tag}> does nothing - :model binds component tags only (for now)`)\n      }\n    } else if (isControlAttr(key)) {\n      // a directive of its own, bound further down (or by renderNodes)\n    } else if (key.startsWith(\":\")) {\n      // :name=\"expr\" binds that one attribute, reactively - the single-key\n      // case :attrs=\"{ name: expr }\" was carrying. `:name` alone is shorthand\n      // for `:name=\"name\"`, like props and :model.<name>, and the shorthand\n      // reads the camelCase variable while the attribute keeps its written\n      // (kebab) name: `:aria-expanded` binds `ariaExpanded`, because\n      // `aria-expanded` as an expression is a subtraction.\n      //\n      // On a tag that may still upgrade this is a *parameter*, not an\n      // attribute: leave it written verbatim, as before, so the upgrade's\n      // renderNestedComponent still finds it. A component tag has no single\n      // root for an attribute to land on anyway (TODOS/2026-07-15.class-directive.md)\n      if (mayUpgrade) el.setAttribute(key, value)\n      else {\n        const name = key.slice(1)\n        const expr = value || kebabToCamel(name)\n        fx.effect(() => applyAttr(el, name, evalExpr(expr, scope)))\n      }\n    } else el.setAttribute(key, value)\n  })\n\n  const bindExpr = node.attrs[\":attrs\"]\n  if (bindExpr !== undefined) {\n    let boundKeys: string[] = []\n\n    fx.effect(() => {\n      boundKeys.forEach(key => el.removeAttribute(key))\n      const bound = evalExpr(bindExpr, scope)\n      boundKeys = bound && typeof bound === \"object\" ? Object.keys(bound) : []\n      boundKeys.forEach(key => applyAttr(el, key, bound[key]))\n    })\n  }\n\n  // :class=\"expr\" adds classes on top of the static `class` attribute, and\n  // :class.<name>=\"expr\" is the single-flag shorthand for `{ <name>: expr }`\n  // (the name routed through classNames, so an empty `:class.` can't reach\n  // classList.add, which throws on \"\"). Both feed one effect and one set of\n  // added classes: only classes this binding added are ever removed, so the\n  // static list survives every re-run, even when the expression names one of\n  // its classes and then drops it (class=\"btn\" :class=\"{ btn: cond }\" keeps\n  // btn on false)\n  const classExpr = node.attrs[\":class\"]\n  const classToggles = Object.entries(node.attrs)\n    .filter(([key]) => key.startsWith(\":class.\"))\n    .map(([key, expr]): [string, string] => [key.slice(\":class.\".length), expr])\n  if (classExpr !== undefined || classToggles.length) {\n    const staticClasses = new Set(classNames(node.attrs.class ?? \"\"))\n    let bound: string[] = []\n\n    fx.effect(() => {\n      const next = classExpr !== undefined ? classNames(evalExpr(classExpr, scope)) : []\n      classToggles.forEach(([name, expr]) => {\n        if (evalExpr(expr, scope)) next.push(...classNames(name))\n      })\n      bound.forEach(name => {\n        if (!next.includes(name) && !staticClasses.has(name)) el.classList.remove(name)\n      })\n      el.classList.add(...next)\n      bound = next\n    })\n  }\n\n  // :text=\"expr\" sets textContent reactively, replacing any children.\n  // :html=\"expr\" sets innerHTML reactively, sanitizing the value first so\n  // untrusted content can't inject scripts/attributes (see sanitizeHTML in\n  // ./dom). Both skip rendering the element's own children/interpolation.\n  // :html.allowed=\"expr\" adds a destination policy for the content's\n  // href/src URLs - evaluated in the same effect, so a policy held in the\n  // store is as reactive as the content itself\n  const textExpr = node.attrs[\":text\"]\n  const htmlExpr = node.attrs[\":html\"]\n  const allowedExpr = node.attrs[\":html.allowed\"]\n  if (allowedExpr !== undefined && htmlExpr === undefined) {\n    console.warn(\"jq79: :html.allowed without :html on the same element does nothing\")\n  }\n  if (textExpr !== undefined) {\n    fx.effect(() => { el.textContent = String(evalExpr(textExpr, scope) ?? \"\") })\n  } else if (htmlExpr !== undefined) {\n    fx.effect(() => {\n      const options = allowedExpr !== undefined ? { allowUrl: normalizeAllowUrl(evalExpr(allowedExpr, scope)) } : undefined\n      el.innerHTML = sanitizeHTML(String(evalExpr(htmlExpr, scope) ?? \"\"), options)\n    })\n  } else if (el instanceof HTMLTemplateElement) {\n    // a plain nested <template> stays what HTML says it is: an inert element\n    // whose children live in .content, which is where whoever clones it looks\n    // for them. They render (bindings and all) and go there - appended as\n    // childNodes they would be in the DOM but in no document fragment, seen by\n    // nothing and rendered by nobody\n    el.content.appendChild(renderNodes(node.children, scope, fx, shadow))\n  } else {\n    el.appendChild(renderNodes(node.children, scope, fx, shadow))\n  }\n\n  // :value / :checked / :selected write the DOM *property*, not the\n  // attribute - the attribute is only a form control's default, and detaches\n  // the moment the user interacts (which is why :attrs=\"{ value }\" stops\n  // driving a typed-in input). One-way, store -> DOM: the way back stays an\n  // explicit @input/@change. :value skips the write when the property\n  // already holds the string, so an unrelated re-run can't move the caret of\n  // the input the user is typing into. Registered after the children render:\n  // :value on a <select> can only pick an <option> that already exists\n  const valueExpr = node.attrs[\":value\"]\n  if (valueExpr !== undefined) {\n    fx.effect(() => {\n      const value = String(evalExpr(valueExpr, scope) ?? \"\")\n      if ((el as HTMLInputElement).value !== value) (el as HTMLInputElement).value = value\n    })\n  }\n  ;([\":checked\", \":selected\"] as const).forEach(attr => {\n    const expr = node.attrs[attr]\n    if (expr === undefined) return\n    const prop = attr.slice(1) as \"checked\" | \"selected\"\n    fx.effect(() => { (el as any)[prop] = !!evalExpr(expr, scope) })\n  })\n\n  return el\n}\n\n// a :if/:elseif*/:else? chain sharing one anchor comment so the active branch\n// can be swapped in place without disturbing sibling positions. Only depends\n// on whatever the branch expressions read (e.g. \"score\"), and skips\n// rebuilding entirely when the active branch hasn't actually changed\nconst renderConditional = (branches: ConditionalBranch[], scope: Record<string, any>, fx: EffectScope, shadow: boolean): Node => {\n  const anchor = document.createComment(\"if\")\n  const wrapper = document.createDocumentFragment()\n  wrapper.appendChild(anchor)\n\n  let current: NodeRange | null = null\n  let activeBranch: ConditionalBranch | null = null\n  let branchFx: EffectScope | null = null\n\n  fx.effect(() => {\n    const next = branches.find(branch => branch.expr === undefined || evalExpr(branch.expr, scope)) ?? null\n    if (next === activeBranch) return\n\n    branchFx?.dispose()\n    if (current) removeRange(current)\n    current = null\n    activeBranch = next\n    if (!next) return\n\n    branchFx = createEffectScope(scope)\n    // bounds captured before inserting: a component branch is a fragment, and\n    // inserting it is what empties it (see boundsOf)\n    const rendered = renderNode(next.node, scope, branchFx, shadow)\n    current = boundsOf(rendered)\n    anchor.parentNode!.insertBefore(rendered, anchor.nextSibling)\n  })\n\n  return wrapper\n}\n\n// defines a loop-local binding directly as `scope`'s own property. Plain\n// assignment (scope[key] = value) would only do this if the key isn't\n// already own on `scope` *or anywhere up its prototype chain* - if it isn't,\n// JS delegates the [[Set]] to whatever's up there, which for us is another\n// reactive proxy's `set` trap: it would wrap `value` as if it were a genuine\n// store mutation and fire a bogus notify() under a name (e.g. \"item\") shared\n// by every unrelated item in every :each on the page. defineProperty always\n// writes to `scope` itself, never delegating, so this can't happen\nconst defineScopeVar = (scope: Record<string, any>, key: string, value: any) => {\n  Object.defineProperty(scope, key, { value, writable: true, enumerable: true, configurable: true })\n}\n\ntype EachEntry = { key: any; item: any; scope: Record<string, any>; range: NodeRange; fx: EffectScope }\n\n// what :each iterates besides arrays: dictionaries, as their entries. Class\n// instances, Maps and the rest stay out - the store doesn't wrap them\n// (isPlainData), so their contents wouldn't be tracked and the list would go\n// silently stale\nconst isPlainObject = (value: any): value is Record<string, any> => {\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n\n// :each=\"item in items\" (or \"item, i in items\" / \"(value, key) in props\"),\n// optionally keyed with :key=\"expr\". Only depends on what the list expression\n// reads, and on each run diffs by key: unchanged items (same key, same item\n// reference) keep their DOM/effects, changed/added ones are (re)rendered,\n// removed ones are disposed. Without :key, an array uses position - fine for\n// append-only lists, wasteful for reordering - and an object uses the\n// property key, which is already the stable identity. Each item gets its own\n// scope via Object.create(scope), so the bindings and `$index` shadow\n// same-named outer names without copying the parent scope's keys\nconst renderEach = (node: TemplateNode, scope: Record<string, any>, fx: EffectScope, shadow: boolean): Node => {\n  const match = node.attrs[\":each\"].match(EACH_PATTERN)\n  if (!match) return document.createComment(`invalid :each expression \"${node.attrs[\":each\"]}\"`)\n\n  const [, itemName, atName, listExpr] = match\n  const keyExpr = node.attrs[\":key\"]\n  const { [\":each\"]: _each, [\":key\"]: _key, ...itemAttrs } = node.attrs\n  const itemNode: TemplateNode = { ...node, attrs: itemAttrs }\n\n  const anchor = document.createComment(\"each\")\n  const wrapper = document.createDocumentFragment()\n  wrapper.appendChild(anchor)\n\n  // :if on the same element is not per-item filtering, and rendering\n  // everything in silence reads like a broken filter - say it out loud\n  if (\":if\" in node.attrs || \":elseif\" in node.attrs || \":else\" in node.attrs) {\n    console.warn(\"jq79: :if/:elseif/:else on a :each element is ignored; filter the list expression instead\")\n  }\n\n  let entries: EachEntry[] = []\n  let warnedDuplicates = false\n\n  fx.effect(() => {\n    const list = evalExpr(listExpr, scope)\n    // both sources normalize to [at, item] pairs: the index for an array, the\n    // property key for a plain object (insertion order). Object entries are\n    // read off the store proxy, so each value is tracked under its own key -\n    // adds, deletes and changes all wake this effect\n    const pairs: [any, any][] = Array.isArray(list)\n      ? list.map((item, index): [any, any] => [index, item])\n      : isPlainObject(list) ? Object.entries(list) : []\n    // buckets rather than a key->entry map: duplicate keys (a user error, but\n    // one that must degrade instead of corrupt) consume entries in order of\n    // appearance, so no entry is ever matched twice - matching one twice is\n    // how a reused row got disposed and a removed one resurrected\n    const previous = new Map<any, EachEntry[]>()\n    entries.forEach(entry => {\n      const bucket = previous.get(entry.key)\n      if (bucket) bucket.push(entry)\n      else previous.set(entry.key, [entry])\n    })\n\n    const seen = new Set<any>()\n    const moved: EachEntry[] = []\n    const nextEntries = pairs.map(([at, item], index): EachEntry => {\n      const itemScope = Object.create(scope)\n      defineScopeVar(itemScope, itemName, item)\n      if (atName) defineScopeVar(itemScope, atName, at)\n      defineScopeVar(itemScope, \"$index\", index)\n      const key = keyExpr !== undefined ? evalExpr(keyExpr, itemScope) : at\n      if (seen.has(key) && !warnedDuplicates) {\n        warnedDuplicates = true\n        console.warn(`jq79: duplicate :key in :each \"${node.attrs[\":each\"]}\"; duplicates pair up by position`)\n      }\n      seen.add(key)\n      const existing = previous.get(key)?.shift()\n\n      if (existing && Object.is(existing.item, item)) {\n        if (existing.scope.$index !== index) moved.push(existing)\n        defineScopeVar(existing.scope, \"$index\", index)\n        if (atName) defineScopeVar(existing.scope, atName, at)\n        return existing\n      }\n\n      if (existing) {\n        existing.fx.dispose()\n        removeRange(existing.range)\n      }\n\n      const itemFx = createEffectScope(scope)\n      // bounds captured before the positioning pass inserts the entry: a\n      // component entry is a fragment, which empties on insertion (see boundsOf)\n      const range = boundsOf(renderNode(itemNode, itemScope, itemFx, shadow))\n      return { key, item, scope: itemScope, fx: itemFx, range }\n    })\n\n    // whatever no new item consumed is gone\n    previous.forEach(bucket => bucket.forEach(entry => {\n      entry.fx.dispose()\n      removeRange(entry.range)\n    }))\n\n    let prevNode: Node = anchor\n    nextEntries.forEach(entry => {\n      if (prevNode.nextSibling !== entry.range.first) moveRangeAfter(entry.range, prevNode)\n      prevNode = entry.range.last\n    })\n\n    // reused entries that changed position: their tracked bindings re-run off\n    // the list notification anyway, but a binding that reads only `$index` or\n    // the named key tracked nothing - refresh them so the move reaches those\n    // too. Untracked, so these runs don't feed this list effect's own deps\n    moved.forEach(entry => untracked(() => entry.fx.refresh()))\n\n    entries = nextEntries\n  })\n\n  return wrapper\n}\n\n// renders a list of sibling template nodes (text + elements), grouping\n// consecutive :if/:elseif/:else nodes into a single conditional block\nconst renderNodes = (nodes: (TemplateNode | string)[], scope: Record<string, any>, fx: EffectScope, shadow = false): DocumentFragment => {\n  const fragment = document.createDocumentFragment()\n  let i = 0\n\n  while (i < nodes.length) {\n    const node = nodes[i]\n\n    if (typeof node === \"string\") {\n      const textNode = document.createTextNode(node)\n      // static text is most of a template (all of its indentation, for a start):\n      // only text with a {{ expression }} in it needs an effect to stay in sync\n      if (node.includes(\"{{\")) fx.effect(() => { textNode.textContent = interpolate(node, scope) })\n      fragment.appendChild(textNode)\n      i++\n      continue\n    }\n\n    if (\":each\" in node.attrs) {\n      fragment.appendChild(renderEach(node, scope, fx, shadow))\n      i++\n      continue\n    }\n\n    if (\":if\" in node.attrs) {\n      const branches: ConditionalBranch[] = [{ expr: node.attrs[\":if\"], node }]\n      i++\n\n      // the branches of a chain are siblings in the AST, but the template writes\n      // them on their own lines - so the whitespace between them is indentation\n      // and nothing else, and it's dropped rather than rendered: only one branch\n      // is ever in the DOM, so there is nothing for it to be a space *between*\n      const nextBranch = (attr: string): TemplateNode | undefined => {\n        let next = i\n        while (next < nodes.length && typeof nodes[next] === \"string\" && !(nodes[next] as string).trim()) next++\n        const candidate = nodes[next]\n        if (typeof candidate === \"object\" && attr in candidate.attrs) {\n          i = next + 1\n          return candidate\n        }\n        return undefined\n      }\n\n      for (let elseif = nextBranch(\":elseif\"); elseif; elseif = nextBranch(\":elseif\")) {\n        branches.push({ expr: elseif.attrs[\":elseif\"], node: elseif })\n      }\n      const elseNode = nextBranch(\":else\")\n      if (elseNode) branches.push({ node: elseNode })\n\n      fragment.appendChild(renderConditional(branches, scope, fx, shadow))\n      continue\n    }\n\n    fragment.appendChild(renderNode(node, scope, fx, shadow))\n    i++\n  }\n\n  return fragment\n}\n\nexport const renderComponent = (component: Component79, data: ReactiveDeepData<Record<string, any>>, shadow = false): Node =>\n  renderNodes(component.template, data, createEffectScope(data), shadow)\n\ntype ComponentParts = {\n  template: TemplateNode[]\n  scripts: TagBlock[]\n  styles: TagBlock[]\n  // pre-resolved modules for `import(...)` calls in setup scripts, keyed by\n  // the literal specifier. Bundlers (the jq79/vite plugin) fill this so\n  // imports resolve from the bundle instead of being fetched at runtime\n  modules?: Record<string, any>\n  // where this component came from (a URL for fetch(), a path for the vite\n  // plugin). Names the setup scripts in devtools - see scriptSourceUrl\n  filename?: string\n  // the components the file's <template name=\"...\"> blocks declared, by name.\n  // Every component parsed out of one file holds this same map - itself\n  // included - which is what makes a sibling usable without an import, and\n  // what lets a <template name=\"TreeNode\"> render a <TreeNode>\n  siblings?: Record<string, Component79>\n  // which of the file's components this is: a template's name, or undefined\n  // for the file's own. The file is the hot-reload unit, so a reparse hands\n  // each live instance the parts belonging to the component it is\n  name?: string\n}\n\nconst VOID_ELEMENTS = new Set([\n  \"area\", \"base\", \"br\", \"col\", \"embed\", \"hr\", \"img\", \"input\",\n  \"link\", \"meta\", \"param\", \"source\", \"track\", \"wbr\",\n])\n\n// a self-closing tag with its attributes; quoted attribute values are matched\n// as whole chunks so a \"/>\" inside one doesn't end the tag early. The tag name\n// admits a dot for the named forms of a tag - <slot.header /> - which is a\n// legal HTML tag name (the tokenizer reads to the first space, \"/\" or \">\")\nconst SELF_CLOSING_RE = /<([A-Za-z][\\w.-]*)((?:\"[^\"]*\"|'[^']*'|[^>\"'])*?)\\/>/g\nconst RAW_BLOCK_RE = /(<script[\\s\\S]*?<\\/script\\s*>|<style[\\s\\S]*?<\\/style\\s*>)/gi\n\n// expands self-closing tags (<MyComponent />, <div />) into explicit\n// open+close pairs BEFORE DOM parsing. The HTML parser ignores the slash and\n// would treat them as unclosed, swallowing the following siblings. Void\n// elements keep their native behavior, and <script>/<style> contents are\n// passed through untouched so code inside them is never rewritten\nconst expandSelfClosingTags = (src: string): string =>\n  src\n    .split(RAW_BLOCK_RE)\n    .map((chunk, i) =>\n      i % 2 === 1 // odd chunks are the captured script/style blocks\n        ? chunk\n        : chunk.replace(SELF_CLOSING_RE, (match, tag: string, attrs: string) =>\n            VOID_ELEMENTS.has(tag.toLowerCase()) ? match : `<${tag}${attrs}></${tag}>`\n          )\n    )\n    .join(\"\")\n\n// a start tag with its attributes, quote-aware so a \">\" inside a value doesn't\n// end it early; and a single spread attribute in name position (preceded by\n// start-or-whitespace), its expression an identifier or member path\nconst OPEN_TAG_RE = /<([A-Za-z][\\w.-]*)((?:\"[^\"]*\"|'[^']*'|[^>\"'])*)>/g\nconst ATTR_SPREAD_RE = /\"[^\"]*\"|'[^']*'|(^|\\s)\\.\\.\\.([A-Za-z_$][\\w$.]*)/g\n\n// `...expr` as an attribute is sugar for :props=\"expr\" (spread an object's\n// properties as props - see renderNestedComponent). Rewritten BEFORE DOM\n// parsing, into a value-based :props.<n>, because the HTML parser lowercases\n// attribute *names*: with the expression in the name, `...userData` would arrive\n// as `...userdata` and resolve to nothing. Moving it into a value - which the\n// parser leaves untouched - keeps camelCase intact. Same pre-parse string move\n// as expandSelfClosingTags, with the same defenses against rewriting code that\n// only looks like a spread: <script>/<style> bodies are split out (a JS `...rest`\n// there is not an attribute), only a start tag's interior is scanned (text\n// between tags is safe), and quoted values are consumed whole so a genuine JS\n// spread in a value (@click=\"f(...args)\", :x=\"{ ...a }\") is skipped. The <n>\n// suffix (per tag) only keeps several spreads' attribute names distinct. A call\n// (`...getProps()`) stops at the paren and is left alone - use :props=\"expr()\"\nconst expandPropsSpread = (src: string): string =>\n  src\n    .split(RAW_BLOCK_RE)\n    .map((chunk, i) =>\n      i % 2 === 1\n        ? chunk\n        : chunk.replace(OPEN_TAG_RE, (_match, tag: string, attrs: string) => {\n            let n = 0\n            const rewritten = attrs.replace(ATTR_SPREAD_RE, (whole, space: string | undefined, expr: string | undefined) =>\n              expr === undefined ? whole : `${space}:props.${n++}=\"${expr}\"`\n            )\n            return `<${tag}${rewritten}>`\n          })\n    )\n    .join(\"\")\n\n// a `:`-prefixed attribute name in name position, and a </slot.name> closing\n// tag. Both quote-aware for the same reason ATTR_SPREAD_RE is: a colon inside\n// a value (@click=\"a ? b : c\", style=\"color: red\") is not an attribute name\nconst ATTR_NAME_RE = /\"[^\"]*\"|'[^']*'|(^|\\s)(:[\\w.$-]+)/g\nconst CLOSE_SLOT_RE = /<\\/slot\\.([\\w.$-]+)(\\s*)>/gi\nconst SLOT_TAG_RE = /^slot\\./i\n\n// camelCase -> kebab-case for every name the HTML parser would lowercase,\n// BEFORE it gets the chance: `:firstName` would arrive as `:firstname` and\n// kebabToCamel (which is what reads these names back out) would have nothing\n// to un-kebab, so the prop, model or slot would silently land under the wrong\n// key. Rewriting to `:first-name` here means both spellings converge on the\n// same camelCase name downstream - the author picks, the runtime doesn't care.\n//\n// Runs FIRST among the pre-parse passes, which is what keeps it simple: it\n// never sees the `:props.<n>` that expandPropsSpread generates, and a\n// <slot.firstName /> is still one occurrence rather than the open+close pair\n// expandSelfClosingTags turns it into. Same defenses as the passes after it -\n// <script>/<style> bodies split out, only start-tag interiors scanned, quoted\n// values consumed whole.\n//\n// Two name positions, not one: attribute names (`:model.firstName`) and the\n// dotted tag names (`<slot.firstName>`), whose closing halves are rewritten\n// too or the parser sees a mismatched pair. Component tags are deliberately\n// left alone - findComponentKey already matches them case-insensitively with\n// dashes stripped, so <UserCard> needs no help and rewriting it would only\n// obscure what the author wrote\nconst kebabTagName = (tag: string): string =>\n  SLOT_TAG_RE.test(tag) ? `slot.${camelToKebab(tag.slice(\"slot.\".length))}` : tag\n\n// the same pass records what it declined to rewrite. An uppercase-initial tag\n// is a claim about a component: HTML's own elements are matched\n// case-insensitively but nobody writes <DIV> by accident, and a custom element\n// may not be spelled that way at all. So <UserCard> is a name the author\n// expected to resolve - which is what lets renderNode throw when it doesn't\n// (see unresolvedComponent).\n//\n// Carried in a *value* rather than left in the tag name, because the value is\n// the one place the HTML parser preserves case - the same move expandPropsSpread\n// makes for `...userData`, and for the same reason. elementToAST lifts it\n// straight off attrs into a field, so no attribute loop downstream ever sees\n// it - and since that lift is unconditional, the name has to be one no author\n// would write: a plain `:component` would eat the prop of that name off\n// <Card :component=\"Widget\" />\nconst COMPONENT_TAG_ATTR = \":jq79-component\"\nconst COMPONENT_TAG_RE = /^[A-Z]/\n\n// appends the stamp inside the tag, *before* a self-closing slash: this pass\n// runs first and expandSelfClosingTags still has to recognize the `/>` that\n// OPEN_TAG_RE swept into the attributes. A slash inside a quoted value can't be\n// mistaken for it - only a trailing one is matched\nconst TRAILING_SLASH_RE = /\\/\\s*$/\n\nconst stampComponentTag = (tag: string, attrs: string): string => {\n  if (!COMPONENT_TAG_RE.test(tag)) return attrs\n  const stamp = ` ${COMPONENT_TAG_ATTR}=\"${tag}\"`\n  const slash = TRAILING_SLASH_RE.exec(attrs)\n  return slash ? `${attrs.slice(0, slash.index)}${stamp}${slash[0]}` : `${attrs}${stamp}`\n}\n\nconst expandNameCase = (src: string): string =>\n  src\n    .split(RAW_BLOCK_RE)\n    .map((chunk, i) =>\n      i % 2 === 1\n        ? chunk\n        : chunk\n            .replace(OPEN_TAG_RE, (_match, tag: string, attrs: string) => {\n              const rewritten = attrs.replace(ATTR_NAME_RE, (whole, space: string | undefined, name: string | undefined) =>\n                name === undefined ? whole : `${space}${camelToKebab(name)}`\n              )\n              return `<${kebabTagName(tag)}${stampComponentTag(tag, rewritten)}>`\n            })\n            .replace(CLOSE_SLOT_RE, (_match, suffix: string, space: string) => `</slot.${camelToKebab(suffix)}${space}>`)\n    )\n    .join(\"\")\n\n// <style scoped> support. Every element of the component's own template is\n// stamped with data-jq79=\"<hash>\" and the style's selectors are rewritten to\n// require that attribute, so its rules can't reach anything the component\n// didn't render. Purely a runtime transform (the browser parses the CSS), so\n// it works the same for a bundled component and one loaded with fetch()\nconst SCOPE_ATTR = \"data-jq79\"\n\n// FNV-1a over the source: stable per definition (not per instance), so N\n// instances of the same component share one refcounted <style> in the head\nconst scopeHash = (src: string): string => {\n  let hash = 2166136261\n  for (let i = 0; i < src.length; i++) hash = Math.imul(hash ^ src.charCodeAt(i), 16777619)\n  return (hash >>> 0).toString(36)\n}\n\nconst stampScope = (nodes: (TemplateNode | string)[], scope: string) => {\n  nodes.forEach(node => {\n    if (typeof node === \"string\") return\n    node.attrs[SCOPE_ATTR] = scope\n    stampScope(node.children, scope)\n  })\n}\n\n// the scope attribute goes on the selector's last compound - the element the\n// rule actually targets - but *before* a pseudo-element, which must stay last\n// (\".a::before\" scopes to \".a[data-jq79='x']::before\", not \"::before[...]\")\nconst scopeSelector = (selectorText: string, scope: string): string =>\n  selectorText\n    .split(\",\")\n    .map(part => {\n      const selector = part.trim()\n      const pseudoAt = selector.indexOf(\"::\")\n      const target = pseudoAt === -1 ? selector : selector.slice(0, pseudoAt)\n      const pseudoElement = pseudoAt === -1 ? \"\" : selector.slice(pseudoAt)\n      return `${target}[${SCOPE_ATTR}=\"${scope}\"]${pseudoElement}`\n    })\n    .join(\", \")\n\n// CSSStyleRule is scoped in place; CSSGroupingRule (@media, @supports,\n// @container) is recursed into; everything else - notably @keyframes, whose\n// \"selectors\" are percentages - is left alone\nconst scopeRules = (rules: CSSRuleList, scope: string) => {\n  Array.from(rules).forEach(rule => {\n    if (rule instanceof CSSStyleRule) rule.selectorText = scopeSelector(rule.selectorText, scope)\n    else if (rule instanceof CSSGroupingRule) scopeRules(rule.cssRules, scope)\n  })\n}\n\n// the CSS parser is the browser's own (no dependency, no hand-rolled parser).\n// Note browsers *silently drop* rules whose selector they can't parse, which\n// is what Vue's :deep()/::v-deep/>>> escape hatches are - unsupported here,\n// and warned about rather than left to vanish\nconst scopeCss = (css: string, scope: string): string => {\n  if (/:deep\\(|::v-deep|>>>/.test(css)) {\n    console.warn(\"jq79: :deep()/::v-deep/>>> are not supported in <style scoped>; the rule will be dropped by the browser\")\n  }\n  const sheet = new CSSStyleSheet()\n  sheet.replaceSync(css)\n  scopeRules(sheet.cssRules, scope)\n  return Array.from(sheet.cssRules).map(rule => rule.cssText).join(\"\\n\")\n}\n\n// a component name has to be PascalCase to be usable: findComponentKey only\n// ever considers capitalized scope keys, so a lowercase name would declare a\n// component no tag could reference. It is also what keeps the named exports\n// from colliding with a definition's own fields, which are all lowercase\nconst COMPONENT_NAME_RE = /^[A-Z][A-Za-z0-9]*$/\n\n// converts a string of HTML into an AST representation of the component:\n// - template: the non-script/style top-level elements, as TemplateNodes\n// - scripts/styles: { attrs, content } blocks in source order\n// - siblings: the components its top-level <template name=\"...\"> declared\nconst parseComponentString = (component: string): ComponentParts => {\n  // example\n  // <script :setup=\"{ fname, lname }\">\n  //   const fullName = `${fname} ${lname}`\n  // </script>\n  //\n  // <div :attrs=\"{ fullName }\"></div>\n  // <div class=\"full-name\">\n  //  {{ fullName }}\n  // </div>\n  //\n  // <style>\n  // .full-name {\n  //  color: red;\n  // }\n  // </style>\n\n  // parsed as the content of a <template> so leading <script>/<style> tags\n  // aren't reparented into <head> by the HTML parser. All three pre-DOM string\n  // rewrites run here, and the order is load-bearing: camelCase names ->\n  // kebab-case first (before `:props.<n>` exists to be mangled and while a\n  // self-closing tag is still one occurrence), then `...expr` -> :props.<n>\n  // (which reads the raw camelCase before the parser can lowercase names),\n  // then self-closing tags\n  const prepared = expandSelfClosingTags(expandPropsSpread(expandNameCase(component)))\n  const parsedDOM = new DOMParser().parseFromString(`<template>${prepared}</template>`, \"text/html\")\n  const root = parsedDOM.querySelector(\"template\") as HTMLTemplateElement\n\n  // a top-level <template> declares another component of this file; everything\n  // else is this one's own\n  const own: Element[] = []\n  const declarations: HTMLTemplateElement[] = []\n  Array.from(root.content.children).forEach(el => {\n    if (el.tagName === \"TEMPLATE\") declarations.push(el as HTMLTemplateElement)\n    else own.push(el)\n  })\n\n  // the file's own component hashes the whole file: every component in it\n  // re-renders on any edit anyway (the file is the hot-reload unit), so a\n  // stamp that changes when a sibling is edited costs nothing, and scopeHash\n  // gets to keep hashing the source it was handed\n  const parts = componentPartsFrom(own, component)\n\n  // one map, shared by reference: it is filled below, after each definition\n  // has already been handed it, so every component of the file sees all the\n  // others *and itself* - which is what makes a recursive component possible\n  const siblings: Record<string, Component79> = {}\n  declarations.forEach(el => {\n    const name = el.getAttribute(\"name\")\n    // ignored rather than fatal, like every other malformed thing here: a bad\n    // save mid-typing must not take the page down, least of all under HMR\n    if (name === null) {\n      console.warn(\"jq79: a top-level <template> without a name declares nothing and was ignored\")\n      return\n    }\n    if (!COMPONENT_NAME_RE.test(name)) {\n      console.warn(\n        `jq79: <template name=\"${name}\"> was ignored - a component name has to be PascalCase, ` +\n        \"or no tag could ever reference it (only capitalized names resolve as components)\"\n      )\n      return\n    }\n    if (name in siblings) {\n      console.warn(`jq79: two <template name=\"${name}\"> in one file; the second was ignored`)\n      return\n    }\n    // its own source is its own scope: a named template is a shadow root\n    // inside a shadow root, so the file's scoped rules stop at its boundary\n    // and its own stop there too\n    siblings[name] = new Component79({ ...componentPartsFrom(Array.from(el.content.children), el.innerHTML), siblings, name })\n  })\n  if (Object.keys(siblings).length) parts.siblings = siblings\n\n  return parts\n}\n\n// the script/style/markup split of one component's top-level elements, with\n// <style scoped> resolved against the source those elements came from - the\n// whole file for its own component, a <template>'s contents for a named one,\n// so the two get different stamps and neither can style the other\nconst componentPartsFrom = (elements: Element[], hashSource: string): ComponentParts => {\n  const scripts: TagBlock[] = []\n  const styles: TagBlock[] = []\n  const template: TemplateNode[] = []\n\n  elements.forEach(el => {\n    const block: TagBlock = { attrs: elementAttrs(el), content: el.textContent ?? \"\" }\n\n    if (el.tagName === \"SCRIPT\") scripts.push(block)\n    else if (el.tagName === \"STYLE\") styles.push(block)\n    else template.push(elementToAST(el))\n  })\n\n  // <style lang=\"scss\"> is compiled by the jq79/vite plugin, so a `lang` still\n  // here means this component never went through it - it was fetched, loaded\n  // from a URL, or built from an inline string. The browser would drop the\n  // uncompiled source without a word, so say it out loud instead\n  styles.forEach(style => {\n    if (\"lang\" in style.attrs) {\n      console.warn(\n        `jq79: <style lang=\"${style.attrs.lang}\"> needs the jq79/vite plugin to compile it. ` +\n        \"This component didn't go through the bundler, so its styles were left uncompiled and the browser will ignore them.\"\n      )\n    }\n  })\n\n  // scoping is resolved once, here: the stamped template and the scoped CSS\n  // are what every instance of this definition renders and injects. An\n  // uncompiled `lang` block is left as it was written - rewriting selectors\n  // in something that isn't CSS yet would only garble what devtools shows\n  const isScoped = (style: TagBlock) => \"scoped\" in style.attrs && !(\"lang\" in style.attrs)\n  if (styles.some(isScoped)) {\n    const scope = scopeHash(hashSource)\n    stampScope(template, scope)\n    styles.forEach(style => {\n      if (isScoped(style)) style.scoped = scopeCss(style.content, scope)\n    })\n  }\n\n  return { template, scripts, styles }\n}\n\n// loads .html URLs as components, delegating anything else to native import().\n// Goes to fetchComponent rather than Component79.fetch because an import wants\n// the component, not the chainable handle the public entry point returns\nconst importResource = (url: string): Promise<any> =>\n  /\\.html?([?#]|$)/.test(url) ? fetchComponent(url) : import(url)\n\n// a relative specifier means \"next to the file that wrote it\", so it is\n// resolved against the component's own URL before importResource sees it -\n// neither of that function's two branches would otherwise land there. The\n// native import() inside it resolves against *this module* (dist/jq79.js), and\n// fetch() against the document; a component in a subdirectory gets a 404 from\n// the first and the page's directory from the second.\n//\n// What comes back is always a fully absolute URL, and that is the load-bearing\n// part rather than a detail of formatting. A *path* would be resolved by that\n// same native import() against the library module's ORIGIN - and the library\n// is the one file on the page most likely to come from somewhere else:\n//\n//   page   http://localhost:8024/craft/app.html\n//   jq79   https://jgermade.github.io/jq79/jq79.js\n//   \"/craft/services/x.js\"  ->  https://jgermade.github.io/craft/services/x.js\n//\n// which is a CORS error naming a host the app never mentioned. Only an\n// absolute URL means the same thing to both branches.\n//\n// For the same reason a *root-absolute* specifier is resolved too, not passed\n// through: `/x.js` means the page's root to whoever wrote it, and the page is\n// the only base under which the two branches agree. Bare specifiers (\"lodash\")\n// are the exception that stays untouched - they belong to the import map or\n// the bundler, and resolving one would quietly turn it into a path.\n//\n// The base is absolutized first, the way hotKey does and for the same reason:\n// the filename may itself be relative (\"./card.html\", from an import() in a\n// parent), and a relative URL cannot be a base\nconst RESOLVABLE_SPECIFIER_RE = /^(?:\\.\\.?\\/|\\/|[a-z][a-z0-9+.-]*:)/i\n\nconst resolveSpecifier = (spec: string, filename: string | undefined): string => {\n  if (!RESOLVABLE_SPECIFIER_RE.test(spec)) return spec\n  try {\n    return new URL(spec, new URL(filename ?? \"\", document.baseURI)).href\n  } catch {\n    return spec\n  }\n}\n\n// ---------------------------------------------------------------------------\n// naming scripts for devtools\n//\n// setup scripts are compiled with new Function (they need `with`, which is a\n// SyntaxError in a module), so no bundler source map can reach them: they show\n// up as an anonymous \"VM1234\" script, breakpoints don't survive a reload, and\n// stack traces name nothing. A //# sourceURL comment fixes all three - the\n// compiled script takes the component's name, so it is findable in the sources\n// tree, keeps its breakpoints, and appears by name in stack traces.\n//\n// The line numbers it reports are the compiled script's own, not the .html\n// file's: the engine wraps a Function body in a header (\"function anonymous(\n// args\\n) {\\n\") that shifts everything down, and no amount of padding can\n// shift code *up* to match a <script> sitting on line 1. Reporting the\n// component's real lines would need a source map, which the runtime doesn't\n// emit today\n// ---------------------------------------------------------------------------\n\n// where a script block came from: the component's filename, and its index\n// among the component's scripts (two scripts in one file need distinct names,\n// or devtools shows only one of them)\ntype ScriptLocation = { filename?: string; index?: number }\n\n// what running a script tells its caller: the promise it settles through, and\n// whether it already finished on this stack. `sync` is the fast path the render\n// gate is built on - see runSetupScript\ntype ScriptRun = { settled: Promise<unknown>; sync: boolean }\n\n// nothing to name an inline component's scripts after, so they stay anonymous\nconst sourceUrlComment = (filename: string | undefined, index: number): string =>\n  filename ? `\\n//# sourceURL=${filename}?jq79-script=${index}` : \"\"\n\n// what a <style> block injects into document.head: the scoped rewrite when it\n// has one, the source otherwise. A shadow root uses `content` directly instead\n// - scoping is what a shadow root already does, and doing both would break the\n// `:host` rules only shadow rendering can have (`:host[data-jq79=...]` matches\n// nothing: the host element is outside the template, so it carries no stamp)\nconst headStyle = (style: TagBlock): string => style.scoped ?? style.content\n\n// document.head styles are shared by content and refcounted, so N instances\n// of the same component (e.g. one per :each item) inject a single <style> tag\n// that goes away when the last instance is destroyed\nconst styleRegistry = new Map<string, { el: HTMLStyleElement; count: number }>()\n\nconst acquireStyle = (content: string) => {\n  let entry = styleRegistry.get(content)\n  if (!entry) {\n    const el = document.createElement(\"style\")\n    el.textContent = content\n    document.head.appendChild(el)\n    entry = { el, count: 0 }\n    styleRegistry.set(content, entry)\n  }\n  entry.count++\n}\n\nconst releaseStyle = (content: string) => {\n  const entry = styleRegistry.get(content)\n  if (entry && --entry.count <= 0) {\n    entry.el.remove()\n    styleRegistry.delete(content)\n  }\n}\n\n// scripts run inside `with (scriptScope)`, where scriptScope's `has` trap\n// claims ownership of every name that is neither a real global, an injected\n// library helper, nor one of the internal helpers. This makes `with` route ALL\n// other reads/writes through the reactive store - even bare assignments to\n// names never declared with let/const, which would otherwise leak onto\n// globalThis - while `console`, `Promise`, `fetch`, etc. still resolve\n// normally. get/set are deliberately not trapped: they default-forward to\n// `scope` (the reactive proxy), preserving tracking and notify.\n// The body is wrapped in an async IIFE so top-level `await` works: everything\n// up to the first await runs synchronously, and later assignments update the\n// DOM reactively when they happen.\n//\n// Returns whether the body ran to completion synchronously, plus the promise it\n// settles through. renderWith needs the *synchronous* answer - a script that\n// finished in this turn cannot hold anything up, so the template can render on\n// this stack exactly as it always has (see the render gate). Asking the promise\n// instead would defer every render by a microtask, including the overwhelmingly\n// common case of a script with no await in it at all.\n//\n// The flag is set on the code's last line, after the `with` block rather than\n// inside it, so the scope proxy never sees the name - and appended, so the\n// author's line numbers (which sourceUrlComment maps for devtools) don't shift\nconst runSetupScript = (code: string, scope: Record<string, any>, effect: (run: () => void) => void, instanceHelpers: Record<string, any> = {}, importer: (url: string) => Promise<any> = importResource, at: ScriptLocation = {}): ScriptRun => {\n  // instanceHelpers are per-component-instance additions (e.g. $emit, which\n  // is bound to this instance's DOM position)\n  const helpers = { ...SETUP_HELPERS, ...instanceHelpers }\n  const scriptScope = new Proxy(scope, {\n    has: (target, key) =>\n      key !== \"$__effect\" && key !== \"$__import\" && key !== \"$__state\" &&\n      (Reflect.has(target, key) || !(key in globalThis) && !(key in helpers)),\n  })\n  const state: { done?: boolean } = {}\n  const result: Promise<void> = new Function(\n    \"$scope\", \"$__effect\", \"$__import\", \"$__state\", ...Object.keys(helpers),\n    `return (async () => { with ($scope) { ${code} }\\n;$__state.done = true })()${sourceUrlComment(at.filename, at.index ?? 0)}`\n  )(scriptScope, effect, importer, state, ...Object.values(helpers))\n  result.catch(error => console.error(\"jq79: error in :setup script\", error))\n  trackScript(result)\n  return { settled: result, sync: state.done === true }\n}\n\n// puts a component's declared props on the store, before any script runs and\n// before the first render: the names, so the template can bind to them even\n// when the parent passes nothing, and the defaults, so it binds to something.\n//\n// A prop the parent *did* pass is already on the store (render() seeds it), so\n// a default only fills an `undefined` - which is also what JS destructuring\n// does with the same pattern, so both modes agree. It happens once, at setup:\n// re-applying a default later would need an effect that reads and writes the\n// same key, and that effect would wake itself forever.\n//\n// `null` props means the component declared no signature at all, which is not\n// the same as declaring an empty one: it keeps today's permissive behavior\nconst declareProps = (store: Record<string, any>, props: PropDecl[] | null) => {\n  props?.forEach(({ name, default: expr }) => {\n    if (store[name] !== undefined) return\n    store[name] = expr === undefined ? undefined : evalExpr(expr, store)\n  })\n}\n\n// a setup script's signature. A bare `<script :setup>` is a CLOSED signature -\n// the same as `<script :setup=\"{}\">`, declaring zero props and taking none -\n// because the difference between \"takes nothing\" and \"takes anything\" should\n// not be a pair of braces somebody didn't type. Permissive is still reachable,\n// it just has to be asked for: `<script :setup=\"_\">`, the same `_` convention\n// factory scripts already use, which parsePropsPattern reads as no signature.\n//\n// Only the empty *value* is closed. An absent attribute (a factory <script>\n// with no :setup at all) stays `null`, so its signature is still read from the\n// factory's first parameter\nconst setupSignature = (script: TagBlock): PropDecl[] | null => {\n  const pattern = script.attrs[\":setup\"]\n  if (pattern === undefined) return null\n  if (pattern.trim() === \"\") return []\n  const props = parsePropsPattern(pattern)\n  if (!props) warnUnreadableSignature(script, pattern)\n  return props\n}\n\n// script blocks already warned about, keyed by the block itself - parsed once\n// and shared by every instance of a definition, the same reason warnUndeclared\n// keys on the template node. It matters for a smaller reason here too:\n// setupSignature is called three times per render (both declared-name passes\n// and the script loop's declareProps), so even one mount would say it thrice\nconst signatureWarned = new WeakSet<TagBlock>()\n\n// a value that isn't a props pattern reads as \"declared no signature\", which is\n// the most permissive mode there is - so a typo doesn't fail, it quietly opts\n// the component out of the contract it was trying to write. That is now the\n// only accidental route left to permissive: a bare :setup is closed and `_` is\n// the opt-out you have to ask for, so the mode nothing lands in by accident is\n// still reachable by getting it wrong. Both of parsePropsPattern's nulls count\n// - not-an-object (\",{ a }\", \"props\") and unbalanced (\"{ a, b\") - and only `_`\n// is exempt, because intent is the sole thing separating it from the typos\nconst warnUnreadableSignature = (script: TagBlock, pattern: string) => {\n  if (pattern.trim() === \"_\" || signatureWarned.has(script)) return\n  signatureWarned.add(script)\n  console.warn(\n    `jq79: :setup=\"${pattern}\" is not a props pattern, so this component declares no ` +\n    `signature and takes whatever a parent passes - write the props it takes ` +\n    `(\"{ a, b }\"), a bare :setup for none, or \"_\" to stay open on purpose`\n  )\n}\n\n// every prop name a component's scripts declare, across both script modes.\n// Read before the store exists, because what a component declares decides\n// which of its file's sibling components it can still see: declaring a name\n// says it comes from the parent, so the file's own definition of that name is\n// deliberately not in this component's scope\nconst declaredPropNames = (scripts: TagBlock[]): Set<string> => {\n  const names = new Set<string>()\n  scripts.forEach(script => {\n    const declarations = parseFactoryProps(script.content) ?? setupSignature(script)\n    declarations?.forEach(({ name }) => names.add(name))\n  })\n  return names\n}\n\n// the same names, but null when NO script declared a signature at all - the\n// distinction declareProps already keeps, and the only one that can decide\n// whether to filter what a parent passes. `<script :setup>` and\n// `<script :setup=\"{}\">` are both closed signatures that take nothing (see\n// setupSignature); `<script :setup=\"_\">` is the permissive one\nconst declaredPropSet = (scripts: TagBlock[]): Set<string> | null => {\n  let names: Set<string> | null = null\n  scripts.forEach(script => {\n    const declarations = parseFactoryProps(script.content) ?? setupSignature(script)\n    if (!declarations) return\n    const into = (names ??= new Set())\n    declarations.forEach(({ name }) => into.add(name))\n  })\n  return names\n}\n\n// drops the props a component didn't declare, so an undeclared name is simply\n// absent from its store rather than quietly present: `{{ label }}` renders\n// empty and `{{ user.name }}` throws on the member access, both at the usage\n// site that got the name wrong. A null signature keeps everything - see\n// declaredPropSet. Silent by design: the main source of extra keys is a\n// `:props` spread of an object wider than the component (`...sdk`), where\n// taking only the declared few is the point, not a mistake to report\nconst pickDeclared = (props: Record<string, any>, declared: Set<string> | null): Record<string, any> => {\n  if (declared === null) return props\n  const out: Record<string, any> = {}\n  Object.keys(props).forEach(key => { if (declared.has(key)) out[key] = props[key] })\n  return out\n}\n\n// names already reported by warnUndeclared, keyed by the template node - which\n// is the usage site itself, built once and shared by every instance it ever\n// renders. So a :each over 200 rows says it once, not once per row, and a\n// definition swap doesn't repeat what the last one already said\nconst undeclaredWarned = new WeakMap<TemplateNode, Set<string>>()\n\n// a parameter the child's signature doesn't declare is dropped by pickDeclared\n// and never reaches its store - `{{ bar }}` renders empty at the other end of\n// the file. Written parameters only: this is handed the named ones (`:bar`,\n// and the prop each :model binds), never a `:props` spread's keys, because a\n// spread of an object wider than the component is the documented, intended use\n// and taking only the declared few is its point - see pickDeclared. A\n// component with no signature at all declares nothing to compare against\nconst warnUndeclared = (node: TemplateNode, name: string, written: string[], declared: Set<string> | null) => {\n  if (declared === null) return\n  const said = undeclaredWarned.get(node) ?? new Set<string>()\n  undeclaredWarned.set(node, said)\n  written.forEach(prop => {\n    if (declared.has(prop) || said.has(prop)) return\n    said.add(prop)\n    console.warn(`jq79: :${prop} is not declared by <${name}> - add it to the :setup signature, or drop it`)\n  })\n}\n\n// the sibling components this one resolves by name, or null when there are\n// none left to resolve. They go on the store's *prototype* rather than in it:\n// the component-key scan walks the chain, so <Row> resolves; they stay out of\n// the data, so Object.keys, snapshots and spreads never see them; and an own\n// key shadows a prototype one, so a prop the parent did pass wins for free\nconst siblingsInScope = (\n  siblings: Record<string, Component79> | undefined,\n  declared: Set<string>\n): Record<string, Component79> | null => {\n  if (!siblings) return null\n  // null-prototype, for the same reason storeApi is: `key in scope` must not\n  // start answering true for toString, constructor and the rest\n  const inScope: Record<string, Component79> = Object.create(null)\n  let any = false\n  Object.entries(siblings).forEach(([name, component]) => {\n    if (declared.has(name)) return\n    inScope[name] = component\n    any = true\n  })\n  return any ? inScope : null\n}\n\n// names a component declared as props and the parent passed nothing for. Such\n// a name can never become a component later - there is no binding on the tag\n// to update it - so a <Tag> reading one is a wiring mistake that can be named\n// on sight, unlike the `undefined` of an import still in flight. Symbol-keyed\n// and non-enumerable: it rides the scope chain (so an :each item scope finds\n// it too) without ever showing up as data\nconst UNFILLED_PROPS = Symbol(\"jq79.unfilledProps\")\n\n// how many of this render generation's scripts have yet to settle, as a live\n// box rather than a snapshot. Rides the scope chain like UNFILLED_PROPS, and\n// for one reader: a <Tag> naming no component in scope is only a mistake once\n// nothing is left that could still supply the name.\n//\n// The count is not the render gate. A script that called $mounted() released\n// the template and is still running - that is the whole point of the call - so\n// at paint time this can be non-zero, and a name arriving from a factory that\n// awaited $mounted() is exactly the case the count keeps quiet. Read live, so\n// an :if that opens after everything settled is judged against the scripts as\n// they are then, not as they were at the first paint\nconst PENDING_SCRIPTS = Symbol(\"jq79.pendingScripts\")\n\ntype PendingScripts = { count: number }\n\n// default-import interop for factory scripts: real modules expose .default,\n// while importing an .html component resolves to the Component79 itself\nconst interopDefault = (mod: any) => (mod && mod.default !== undefined ? mod.default : mod)\n\n// runs a factory script: the (rewritten) module body executes in plain\n// lexical strict-mode scope - no `with`, no implicit reactivity - with the\n// library helpers as parameters, then the default export is called with the\n// instance context and a returned object is merged into the store. A fully\n// synchronous body invokes the factory before the first render, matching\n// setup-script timing; bodies with top-level await (static imports included)\n// resolve later and the template updates reactively\nconst runFactoryScript = (code: string, scope: Record<string, any>, effect: (run: () => void) => void, instanceHelpers: Record<string, any> = {}, importer: (url: string) => Promise<any> = importResource, at: ScriptLocation = {}): ScriptRun => {\n  const helpers = { ...SETUP_HELPERS, ...instanceHelpers }\n  const $__exports: { default?: (props: Record<string, any>, ctx: Record<string, any>) => any; done?: boolean } = {}\n  const result: Promise<void> = new Function(\n    \"$__exports\", \"$__default\", \"$__import\", ...Object.keys(helpers),\n    `return (async () => { \"use strict\";\\n${code}\\n;$__exports.done = true })()${sourceUrlComment(at.filename, at.index ?? 0)}`\n  )($__exports, interopDefault, importer, ...Object.values(helpers))\n\n  const logError = (error: any) => console.error(\"jq79: error in factory script\", error)\n  let invoked = false\n  // what invoke() is still waiting on, memoized: it is called from both paths\n  // below and does its work once, but the *second* caller is the one whose\n  // promise is tracked - without this it would see `undefined` and count the\n  // script as settled while an async factory's bindings are still on the way\n  let merging: Promise<void> | undefined\n  const invoke = (): Promise<void> | undefined => {\n    if (invoked) return merging\n    invoked = true\n    const factory = $__exports.default\n    if (typeof factory !== \"function\") return undefined\n    const merge = (bindings: any) => {\n      if (bindings && typeof bindings === \"object\") Object.assign(scope, bindings)\n    }\n    // the sync path is invoked straight from render(), so a throwing factory\n    // must be caught here too - not just by the `result` rejection handler\n    try {\n      // props first, ctx second. Both are the store: the pattern destructures\n      // the props it declared (copying, as destructuring does - $props is the\n      // live view for a primitive the parent reassigns later)\n      const returned = factory(scope, { $data: scope, $props: scope, $effect: effect, ...instanceHelpers })\n      if (returned instanceof Promise) merging = returned.then(merge).catch(logError)\n      else merge(returned)\n    } catch (error) {\n      logError(error)\n    }\n    return merging\n  }\n\n  // tracked through the merge, not just the module body: a factory's names\n  // reach the store in `merge`, and a template expression that reads one before\n  // then is not an authoring mistake (see reportExprError)\n  const settled = result.then(invoke, logError)\n  trackScript(settled)\n  if ($__exports.done) invoke() // fully-sync body: factory runs before first render\n  // sync only if the bindings are already on the store: a factory whose body\n  // finished but whose *factory* returned a promise (an async factory, or one\n  // that awaits $mounted()) still has names on the way, and the render gate\n  // must treat it as pending rather than race its merge\n  return { settled, sync: $__exports.done === true && merging === undefined }\n}\n\n// ---------------------------------------------------------------------------\n// hot reload\n//\n// Both delivery paths want the same thing when a .html file changes: reparse\n// it, and re-render every live instance of it in place, keeping its data. The\n// swap lives in the runtime (hotReplace, below) so jq79/dev and the Vite\n// plugin share one implementation instead of two - and so it can reach the\n// private fields it needs (the markers, the holding fragment) rather than\n// poking at them from outside, which is what the plugin used to do.\n//\n// Finding the instances is the part only the runtime can do: a component\n// fetched at runtime is reachable from nothing but the DOM it rendered. So\n// instances register themselves - but only once a page opts in, before the\n// runtime loads. Nothing here costs a bundled app anything: with the registry\n// off, an instance is not tracked at all.\n// ---------------------------------------------------------------------------\n\nconst HOT_FLAG = \"__JQ79_HMR_ENABLED__\"\nconst HOT_RUNTIME = \"__JQ79_HMR__\"\n\n// live instances by filename. WeakRef because a destroyed component that the\n// page has dropped must stay collectable: `:each` churns through clones\nlet hotRegistry: Map<string, Set<WeakRef<Component79>>> | null = null\n\nconst hotRegister = (instance: Component79) => {\n  if (!hotRegistry || !instance.filename) return\n  let refs = hotRegistry.get(instance.filename)\n  if (!refs) hotRegistry.set(instance.filename, (refs = new Set()))\n  refs.add(new WeakRef(instance))\n}\n\n// the same file reaches the runtime under different names - \"./card.html\" from\n// an import() in a setup script, \"/cards/card.html\" from a fetch, \"cards/card.\n// html\" from the dev server that watched it - and they all have to land on one\n// key. Resolving against the page is what settles them\nconst hotKey = (filename: string): string => {\n  try {\n    return new URL(filename, document.baseURI).pathname\n  } catch {\n    return filename\n  }\n}\n\n// swaps the file's new source into every instance that came from `filename`,\n// and returns how many of them were *on the page* and so re-rendered. Zero\n// means the change is not visible anywhere - the file is a page rather than a\n// component, or nothing has mounted it yet - and the caller (a dev server)\n// should fall back to reloading. Definitions and instances that have been\n// destroyed but not yet collected are patched all the same; they just don't\n// count, because nothing on screen changed for them\nexport const hotUpdate = (filename: string, src: string): number => {\n  if (!hotRegistry) return 0\n\n  const key = hotKey(filename)\n  // parsed once and shared by every instance - which is already what a\n  // definition and the clones :component makes from it do\n  const parts = parseComponentString(src)\n  // the file is the hot-reload unit, so one reparse serves every component it\n  // declares: an instance is handed the parts of the component it *is*, by\n  // name. A name that is no longer in the file (a <template> renamed or\n  // deleted) has no parts to be given, and only a reload can fix the page\n  let orphaned = false\n  const partsFor = (instance: Component79): ComponentParts | null =>\n    instance.name === undefined ? parts : parts.siblings?.[instance.name] ?? null\n\n  let rerendered = 0\n  for (const [name, refs] of hotRegistry) {\n    if (hotKey(name) !== key) continue\n    for (const ref of refs) {\n      const instance = ref.deref()\n      if (!instance) {\n        refs.delete(ref) // collected since the last update\n        continue\n      }\n      const next = partsFor(instance)\n      if (!next) {\n        orphaned = true\n        continue\n      }\n      if (instance.hotReplace(next)) rerendered++\n    }\n    if (!refs.size) hotRegistry.delete(name)\n  }\n  return orphaned ? 0 : rerendered\n}\n\n// starts tracking instances, so hotUpdate can find them. jq79/dev's client\n// calls this through the global handshake at the foot of this file; it is\n// exported so a bundled app - or a test - can opt in directly\nexport const enableHotReload = (): void => {\n  hotRegistry ??= new Map()\n  ;(globalThis as any)[HOT_RUNTIME] = { update: hotUpdate }\n}\n\ntype EmitListener = (event: CustomEvent, payload: any) => void\n\n// how long a first render may sit behind its scripts before the console says so\nconst STUCK_RENDER_DELAY = 3000\n\n// a script that neither returns nor calls $mounted() holds the template\n// forever, and the failure looks like nothing at all: no error, no markup, a\n// component indistinguishable from one nobody mounted. So the wait is loud\n// after a few seconds - and it keeps waiting, because rendering on a timer\n// would make the moment of the first render depend on the machine it runs on.\n//\n// Armed only on the deferred path, so a page of synchronous components creates\n// no timers at all\nconst warnIfStuck = (component: Component79, gates: Promise<void>[]) => {\n  const timer = setTimeout(() => {\n    console.warn(\n      `jq79: ${component.name ? `<${component.name}>` : \"a component\"}${component.filename ? ` (${component.filename})` : \"\"} ` +\n      `has been waiting ${STUCK_RENDER_DELAY / 1000}s for a :setup script and has rendered nothing. ` +\n      \"The template waits until every script returns or calls $mounted() - add an \" +\n      \"await $mounted() above the slow part to render first and fill in after.\"\n    )\n  }, STUCK_RENDER_DELAY)\n  // unref where it exists (node/vitest): a pending timer must not be what keeps\n  // a process alive. Browsers have no such notion and no such need\n  ;(timer as any)?.unref?.()\n  Promise.all(gates).then(() => clearTimeout(timer))\n}\n\nconst fetchComponent = async (url: string): Promise<Component79> => {\n  const response = await fetch(url)\n  if (!response.ok) throw new Error(`failed to fetch component from ${url}: ${response.status}`)\n  // the URL names the component's scripts in devtools, and is where the\n  // browser will look for the source when a breakpoint lands in one\n  return new Component79(await response.text(), { filename: url })\n}\n\n// a parsed single-file component. Typical lifecycle:\n//\n//   const jq79 = new Component79(src)   // or await Component79.fetch(url)\n//   jq79.on(\"submit\", (e, payload) => {}) // hear this instance's $emit events\n//   jq79.mount(\"#app\", { user })        // render (reactive DOM, scripts, styles) + attach\n//   ...                                 // (mountShadow mounts into a shadow root)\n//   jq79.detach()                       // detach, keeping state - mount() re-attaches\n//      .destroy()                      // dispose effects and remove styles\nexport class Component79 {\n  // the version of jq79 this class came from, so a page can tell which build it\n  // loaded (a CDN <script> pins nothing on its own)\n  static readonly version: string = VERSION\n\n  template: TemplateNode[]\n  scripts: TagBlock[]\n  styles: TagBlock[]\n  // pre-resolved modules for setup-script `import(...)` calls (see\n  // ComponentParts.modules); checked before falling back to fetch/import\n  modules?: Record<string, any>\n  // the component's origin, used to name its scripts in devtools\n  filename?: string\n  // the other components declared in the same file, by name (see\n  // ComponentParts.siblings). They are also this definition's own properties,\n  // so `const { Row } = await Component79.fetch(url)` reaches them\n  siblings?: Record<string, Component79>\n  // this component's name inside its file, for the components a <template>\n  // declared; the file's own component has none - it is the default, and a\n  // default is named by whoever imports it\n  name?: string\n  // the content the usage site handed this instance, by slot name (see the\n  // slots section). Not part of a definition - it belongs to the tag that\n  // wrote it - so renderNestedComponent sets it on the instance it creates,\n  // and every render reads it from here: a hot reload re-renders from a data\n  // snapshot, which a symbol on the store would not survive\n  slots?: SlotMap\n  // the writeback half of :model, same story: the function that assigns into\n  // the parent, set by renderNestedComponent before the first render and\n  // called by this instance's $updateModel. Kept outside the render generation\n  // so it survives re-render and hot reload. Absent means no :model on the tag\n  // (or no tag at all - a root mount), which makes every $updateModel a no-op.\n  // Internal: set by the usage site, not part of the public API\n  modelWriteback?: (name: string | undefined, value: any) => boolean\n\n  data: ReactiveDeepData<Record<string, any>> | null = null\n\n  private fx: EffectScope | null = null\n  // holds the rendered nodes while detached; anchors keep this fragment as\n  // their parentNode, so effects keep the (detached) DOM up to date and a\n  // later mount() shows current state\n  private content: DocumentFragment | null = null\n  // markers bracketing the component's output so detach() can collect nodes\n  // that :if/:each inserted next to the anchors after mounting\n  private startMarker: Comment | null = null\n  private endMarker: Comment | null = null\n  // shadow rendering keeps per-instance <style> elements; head rendering goes\n  // through the shared refcounted styleRegistry instead\n  private styleEls: HTMLStyleElement[] = []\n  private ownsSharedStyles = false\n  private useShadow = false\n  private mountRoot: Element | ShadowRoot | DocumentFragment | null = null\n  // settles the $mounted() promise handed to this render generation's scripts\n  private resolveMounted: (() => void) | null = null\n  // whether this generation's template has been built. A render held back by a\n  // script (see the gate in renderWith) has markers but no nodes, and $mounted()\n  // must not resolve on attach alone - a script awaiting it would wake to an\n  // empty component and find nothing to query\n  private renderDone = false\n  // instance-level listeners for $emit events, registered with on(). Kept\n  // outside the render generation so they survive re-render and destroy()\n  private emitListeners = new Map<string, Set<EmitListener>>()\n\n  constructor(src: string | ComponentParts, options: { modules?: Record<string, any>; filename?: string } = {}) {\n    const parts = typeof src === \"string\" ? parseComponentString(src) : src\n    this.template = parts.template\n    this.scripts = parts.scripts\n    this.styles = parts.styles\n    this.modules = options.modules ?? (typeof src === \"string\" ? undefined : src.modules)\n    this.filename = options.filename ?? (typeof src === \"string\" ? undefined : src.filename)\n    this.siblings = parts.siblings\n    this.name = parts.name\n    this.adoptSiblings()\n    hotRegister(this) // a no-op unless the page enabled hot reload\n  }\n\n  // the parser builds a file's sibling definitions before anyone has told it\n  // where the file came from, so whoever holds the parse hands its origin down\n  // - and keeps doing it after a hot reload, which parses the file afresh.\n  // Without it a reloaded child would have no filename, and an instance with\n  // no filename is not tracked: the next edit would never reach it\n  private adoptSiblings() {\n    if (!this.siblings) return\n    Object.entries(this.siblings).forEach(([name, sibling]) => {\n      sibling.filename ??= this.filename\n      sibling.modules ??= this.modules\n      // the file's own component also *is* the file: its named components hang\n      // off it as properties, which is what `const { Row } = …` reads (and\n      // what the bundler re-exports by name)\n      if (!this.name) (this as any)[name] = sibling\n    })\n  }\n\n  // swaps this component's parsed parts for `src`'s and, if it is on the page,\n  // re-renders it where it stands - seeded with a snapshot of its data, so\n  // props and store values survive (the setup script runs again, so whatever it\n  // initializes is reset). Returns whether it re-rendered: an instance that was\n  // never rendered is a *definition*, and patching its parts is all there is to\n  // do - the clones :component made from it are instances in their own right,\n  // registered under the same filename, and re-render themselves.\n  //\n  // Dev-only, and not part of the public API: jq79/dev and the Vite plugin call\n  // it when a file changes. It re-attaches against the markers rather than\n  // mountRoot on purpose - a nested clone is mounted into a fragment that is\n  // then emptied into the page, so its mountRoot is a stale, detached fragment\n  // while its markers sit where its DOM actually is\n  hotReplace(src: string | ComponentParts): boolean {\n    const parts = typeof src === \"string\" ? parseComponentString(src) : src\n    // the source just changed, so what was already said about it no longer\n    // applies: without this the author fixes the typo, saves, and the next typo\n    // in the same expression is deduped away against the old one. `compiled`\n    // needs no such reset - it is keyed by expression text, so edited source is\n    // a different key\n    reportedExprErrors.clear()\n    pendingReports.clear()\n    reportedFailedExprs.clear()\n    const marker = this.startMarker\n    const rendered = !!(marker && this.content)\n\n    // where its output sits now, if it is on the page. A rendered-but-detached\n    // instance (markers in the holding fragment) re-renders detached, and a\n    // later mount() attaches the new output - like any update it missed away\n    const live = rendered && marker!.isConnected\n    const parent = live ? (marker!.parentNode as Element | ShadowRoot | DocumentFragment) : null\n    const before = live ? this.endMarker!.nextSibling : null\n    const data = { ...this.data }\n    const shadow = this.useShadow\n\n    // destroy() releases the styles it acquired, so it has to run while\n    // this.styles is still the *old* set - swapping the parts first would leak\n    // the old stylesheet into the head and release a new one nobody holds\n    if (rendered) this.destroy()\n\n    this.template = parts.template\n    this.scripts = parts.scripts\n    this.styles = parts.styles\n    // the file's other components as they are now: the next render resolves\n    // <Row> against these, so a parent picks up an edited child even when the\n    // child's own instances are patched separately\n    this.siblings = parts.siblings\n    this.adoptSiblings()\n    if (!rendered) return false // a definition: its clones re-render themselves\n\n    this.renderWith(data, shadow)\n    if (!parent) return false\n\n    // shadow styles live inline, right before the DOM they style (attach()\n    // appends them ahead of the content), so they go back the same way\n    if (shadow) this.styleEls.forEach(el => parent.insertBefore(el, before))\n    parent.insertBefore(this.content!, before)\n    this.mountRoot = parent\n    this.settleMounted()\n    return true\n  }\n\n  // downloads and parses a component, handing back a PendingComponent79: a\n  // handle that can be mounted right away, and that awaits to this component -\n  // so both of these are the whole program\n  //\n  //   Component79.fetch(\"./app.html\").mount(\"main\")\n  //   const app = await Component79.fetch(\"./app.html\")\n  static fetch(url: string): PendingComponent79 {\n    if (Array.isArray(url)) throw new TypeError(\"Component79.fetch takes one URL; use fetchAll for an array\")\n    return new PendingComponent79(fetchComponent(url))\n  }\n\n  // fetches them all at once and resolves to the components in the same order,\n  // so one await destructures them - and, like Promise.all, the first failure\n  // rejects the whole thing. A plain promise, not a handle: mounting a *list*\n  // of components has no single meaning\n  static fetchAll(urls: string[]): Promise<Component79[]> {\n    return Promise.all(urls.map(fetchComponent))\n  }\n\n  // subscribes to this instance's $emit events, on top of the DOM CustomEvent\n  // dispatch - so it hears emits even while the component is detached (where\n  // the event has no ancestors to bubble to). Chainable; can be called before\n  // render()\n  on(eventName: string, listener: EmitListener): this {\n    if (!this.emitListeners.has(eventName)) this.emitListeners.set(eventName, new Set())\n    this.emitListeners.get(eventName)!.add(listener)\n    return this\n  }\n\n  off(eventName: string, listener: EmitListener): this {\n    this.emitListeners.get(eventName)?.delete(listener)\n    return this\n  }\n\n  render(data: Record<string, any> = {}): this {\n    return this.renderWith(data, false)\n  }\n\n  // like render(), but styles are injected into a shadow root attached to the\n  // mount target instead of document.head, so they don't leak globally\n  renderShadow(data: Record<string, any> = {}): this {\n    return this.renderWith(data, true)\n  }\n\n  private renderWith(data: Record<string, any>, shadow: boolean): this {\n    this.destroy()\n\n    // what this component can see of its file's other components, and which of\n    // its declared props arrived empty - both decided by the signature, before\n    // the store exists (see siblingsInScope / UNFILLED_PROPS)\n    const declared = declaredPropNames(this.scripts)\n    const siblingScope = siblingsInScope(this.siblings, declared)\n    const raw: Record<string, any> = siblingScope\n      ? Object.assign(Object.create(siblingScope), data)\n      : { ...data }\n    const unfilled = new Set([...declared].filter(name => !(name in data)))\n    if (unfilled.size) Object.defineProperty(raw, UNFILLED_PROPS, { value: unfilled })\n    // the slot content, for the <slot>s the template renders, and the static\n    // map of which names were filled, for the component to ask about\n    // (`<footer :if=\"$slots.footer\">`). Filled at the usage site, so it can\n    // only change when the tag itself re-renders - which builds a new instance\n    if (this.slots) Object.defineProperty(raw, SLOTS, { value: this.slots })\n    // in place before the store wraps it, because the scripts that increment it\n    // run against the store and the template reads it back through the same\n    // scope chain. Read back out of `raw` where it is needed rather than kept\n    // in a local: this frame is on the stack for the whole of the subtree it\n    // renders, so a component nested inside itself pays for it once per level -\n    // and the depth guard at MAX_NESTING_DEPTH only beats a RangeError while\n    // this function stays small (see the note in docs/development.md)\n    Object.defineProperty(raw, PENDING_SCRIPTS, { value: { count: 0 } as PendingScripts })\n\n    const store = $reactive(raw)\n    const fx = createEffectScope(store)\n    this.data = store\n    this.fx = fx\n    this.useShadow = shadow\n\n    this.startMarker = document.createComment(\"jq79\")\n    this.endMarker = document.createComment(\"/jq79\")\n\n    // $emit dispatches a bubbling CustomEvent from this instance's start\n    // marker, so once mounted it travels up the real DOM and parents can\n    // listen on any ancestor (or with @event-name on a wrapping element).\n    // Captures the marker rather than `this` so a later re-render's scripts\n    // can't dispatch from the wrong generation - the same guard keeps stale\n    // generations from reaching the instance's on() listeners.\n    // The on() channel runs *first* (it's where @event on a component tag is\n    // wired - see wireTagEvent) so its listeners can shape the DOM dispatch:\n    // stopPropagation() there keeps the event off the DOM entirely, and the\n    // event is cancelable so preventDefault() - from either channel - flips\n    // the return to false, telling the emitting child \"the parent vetoed\"\n    const marker = this.startMarker\n    // model:update used to be the writeback's event name; it is a direct call\n    // now ($updateModel), so an emit under that name reaches nothing. Said\n    // once per generation rather than per keystroke, and said at all because\n    // the alternative is a child whose edits silently stop arriving\n    let warnedModelUpdate = false\n    const $emit = (eventName: string, payload?: any): boolean => {\n      if (eventName === \"model:update\" && !warnedModelUpdate) {\n        warnedModelUpdate = true\n        console.warn(\"jq79: $emit('model:update', …) no longer feeds :model - call $updateModel(value) or $updateModel(name, value) instead\")\n      }\n      const event = new CustomEvent(eventName, { detail: payload, bubbles: true, composed: true, cancelable: true })\n      if (marker === this.startMarker) {\n        this.emitListeners.get(eventName)?.forEach(listener => listener(event, payload))\n      }\n      // cancelBubble is the spec's legacy name, but it's the only *readable*\n      // accessor for the stop-propagation flag - hence the deprecation hint\n      if (!event.cancelBubble) marker.dispatchEvent(event)\n      return !event.defaultPrevented\n    }\n\n    // `await $mounted()` suspends a setup script until the component is\n    // rendered *and* attached, so code below it can querySelector its own DOM.\n    // If this instance is never mounted, the promise stays pending and the\n    // script's tail never runs.\n    //\n    // Calling it is also how a script releases the first render - see the gate\n    // below - so the two halves of the contract are one call: \"put me on the\n    // page, and don't wait for the rest of me\"\n    let resolveMounted!: () => void\n    const mounted = new Promise<void>(resolve => { resolveMounted = resolve })\n    this.resolveMounted = resolveMounted\n    this.renderDone = false\n\n    // $self / $$self mirror $ / $$ but only search this instance's own\n    // output: the sibling nodes between its markers. They work detached too\n    // (the holding fragment keeps markers and rendered nodes as siblings),\n    // though the template renders after the scripts run, so they only find\n    // something from post-await code or callbacks\n    const endMarker = this.endMarker\n    const $$self = (selector: string): Element[] => {\n      const found: Element[] = []\n      for (let node: Node | null = marker.nextSibling; node && node !== endMarker; node = node.nextSibling) {\n        if (node instanceof Element) {\n          if (node.matches(selector)) found.push(node)\n          found.push(...Array.from(node.querySelectorAll(selector)))\n        }\n      }\n      return found\n    }\n    const $self = (selector: string): Element | null => $$self(selector)[0] ?? null\n\n    // import() calls whose specifier was pre-resolved by a bundler (the\n    // modules map) get the bundled module; everything else falls back to the\n    // runtime importResource (fetch for .html, native import otherwise),\n    // relative to this component's file. The map is keyed by the literal\n    // specifier the script wrote, so it is consulted *before* resolution -\n    // what the bundler hoisted and what the source says are the same string\n    const modules = this.modules\n    const $import = (url: string): Promise<any> =>\n      modules && url in modules\n        ? Promise.resolve(modules[url])\n        : importResource(resolveSpecifier(url, this.filename))\n\n    // the writeback half of :model, from the child's side: one argument is the\n    // value for the default model (the bare :model), two are a name and a\n    // value. Arity is what tells them apart, so the value is never inspected -\n    // an object with `name`/`value` keys is just a value, which is exactly\n    // what a payload-shaped contract could not promise. Returns whether a\n    // bound model took it; no :model at the usage site is a silent no-op,\n    // since a child may be designed to work bound or unbound\n    const $updateModel = (...args: [value?: any] | [name: string, value: any]): boolean => {\n      const [name, value] = args.length > 1 ? args as [string, any] : [undefined, args[0]]\n      // the same stale-generation guard $emit has: destroy() nulls the marker,\n      // so a closure the old child leaked (a timer, a registered callback)\n      // cannot keep writing a parent that replaced it\n      if (marker !== this.startMarker) return false\n      return this.modelWriteback?.(name, value) ?? false\n    }\n\n    // the names a component answers on top of its store: $emit, so an inline\n    // handler can emit without routing through a setup function\n    // (@input=\"$emit('update', $event.target.value)\"), $updateModel, the\n    // writeback a :model binding listens for, and $slots, the static map of\n    // the names the usage site filled, so a wrapper can be dropped when\n    // nothing filled it (<footer :if=\"$slots.footer\">). All reach the\n    // template (through templateScope, below) and both script modes (as\n    // instance helpers), and a same-named store key shadows any of them.\n    // Null-prototype, for the same reason storeApi is: `key in injected` must\n    // not start answering true for toString, constructor and the rest\n    const injected: Record<string, any> = Object.assign(Object.create(null), {\n      $emit,\n      $updateModel,\n      $slots: Object.fromEntries(Object.keys(this.slots ?? {}).map(name => [name, true])),\n    })\n\n    // scripts run before the template renders so `$:` values are initialized;\n    // a `:mounted` script defers entirely until mount() instead. A top-level\n    // `export default` switches the script to factory mode (plain lexical JS)\n    // a `:mounted` script is deferred by prepending the await on the code's own\n    // first line, so deferring doesn't shift the lines devtools reports for it\n    const defer = (code: string) => `await $mounted();${code}`\n\n    // what the first render is still waiting for. A script holds the template\n    // back until it returns or calls $mounted() - whichever comes first - so\n    // `let rows = await fetch(...)` renders once, with rows, instead of\n    // rendering empty and filling in. `:mounted` is not a special case here: it\n    // *is* a script that yields on line 0, which is what `defer` above writes.\n    //\n    // One gate per script, not one per instance: a script yielding must not\n    // release the render on behalf of a sibling script that is still fetching\n    const gates: Promise<void>[] = []\n    let allSync = true\n\n    this.scripts.forEach((script, index) => {\n      let resolveGate!: () => void\n      gates.push(new Promise<void>(resolve => { resolveGate = resolve }))\n      // whether this gate is already open on *this* stack, which is not the\n      // same as the script having finished: a script that yields immediately\n      // (`await $mounted()` on its first line, which is what `:mounted`\n      // compiles to) never finishes synchronously but holds nothing up either.\n      // Reading the promise instead would push every such render a microtask\n      // later, for no one's benefit\n      let open = false\n      const release = () => { open = true; resolveGate() }\n      // this script's own view of $mounted: the call releases its gate, the\n      // promise it returns is the instance's (one mount, one resolution)\n      const $mounted = () => { release(); return mounted }\n      // the file's other components are passed as parameters of the compiled\n      // script, not just left on the store's prototype: a factory script runs\n      // as plain lexical JS with no `with`, so a bare `Row` in one would\n      // resolve to nothing at all. In setup mode this composes with `with` -\n      // scriptScope's `has` declines any name that is a helper, so the\n      // parameter is what the name resolves to\n      const instanceHelpers = { $mounted, $self, $$self, ...injected, ...siblingScope }\n      const at: ScriptLocation = { filename: this.filename, index }\n      const deferred = \":mounted\" in script.attrs\n      const factoryCode = transformFactoryScript(script.content)\n      const run = ((): ScriptRun => {\n        if (factoryCode !== null) {\n          // a factory publishes its names by returning them, so one that yields\n          // before it returns renders against a store where none of them exist.\n          // In factory mode `:mounted` yields on line 0, which means *always* -\n          // and unlike a setup script there is no way to put the useful half\n          // above the yield. Awaiting $mounted() inside the factory does what\n          // the author meant, and is what the message points at\n          if (deferred) {\n            console.warn(\n              \"jq79: :mounted on a factory script renders the template before the factory has returned, \" +\n              \"so none of its bindings exist yet - await $mounted() inside the factory instead.\"\n            )\n          }\n          declareProps(store, parseFactoryProps(script.content))\n          const body = deferred ? defer(factoryCode) : factoryCode\n          return runFactoryScript(body, store, fx.effect, instanceHelpers, $import, at)\n        }\n        const { vars, code } = transformSetupScript(script.content)\n        declareProps(store, setupSignature(script))\n        // pre-declare script vars on the store so `with` resolves assignments\n        // to them (and reads of them) through the reactive proxy\n        vars.forEach(name => { if (!(name in store)) (store as any)[name] = undefined })\n        const body = deferred ? defer(code) : code\n        return runSetupScript(body, store, fx.effect, instanceHelpers, $import, at)\n      })()\n      // a script that threw has nothing left to contribute, so its rejection\n      // releases the gate exactly as completion does - the error is already\n      // reported by the runner, and holding the template hostage to it would\n      // turn one broken script into a blank component. It also stops counting\n      // as a source of names, for that same reason.\n      //\n      // A script that finished on this stack is counted at zero rather than\n      // incremented and decremented a microtask later: its names are on the\n      // store already, and the promise it settles through does not resolve\n      // until after the synchronous paint - which is every paint, for the\n      // components that have no await in them at all\n      if (run.sync) run.settled.then(release, release)\n      else {\n        const pending: PendingScripts = (raw as any)[PENDING_SCRIPTS]\n        pending.count++\n        const settle = () => { pending.count--; release() }\n        run.settled.then(settle, settle)\n      }\n      if (!run.sync && !open) allSync = false\n    })\n\n    const content = document.createDocumentFragment()\n    // the injected names, served by has/get only - never as own keys - so\n    // Object.keys, snapshot spreads and the component-key scan don't see them,\n    // and every read still forwards through the reactive store, keeping\n    // dependency tracking intact\n    const templateScope = new Proxy(store as Record<string, any>, {\n      has: (target, key) => (typeof key === \"string\" && key in injected) || Reflect.has(target, key),\n      get: (target, key, receiver) =>\n        typeof key === \"string\" && key in injected && !Reflect.has(target, key)\n          ? injected[key]\n          : Reflect.get(target, key, receiver),\n    })\n    // the markers go in either way, so render() returns something mountable\n    // whether or not the template has been built yet: they are what detach()\n    // collects between and what the deferred pass inserts before, exactly as\n    // :if/:each anchors already work. That is what keeps render() and mount()\n    // synchronous while the first render itself is allowed to wait\n    content.append(this.startMarker, this.endMarker)\n    this.content = content\n    if (allSync) {\n      // nothing is pending, so the template is built on this stack - the\n      // ordinary case, and byte-for-byte the timing render() has always had.\n      //\n      // Written out rather than routed through the closure below on purpose: a\n      // component that nests itself recurses through here, so one extra frame\n      // per level is one fewer level before the stack gives out - enough, when\n      // this was a shared `paint()`, to overflow *underneath* the depth guard\n      // at MAX_NESTING_DEPTH and turn a named error back into a RangeError\n      this.endMarker.parentNode!.insertBefore(renderNodes(this.template, templateScope, fx, shadow), this.endMarker)\n      this.renderDone = true\n      this.settleMounted()\n    } else {\n      Promise.all(gates).then(() => {\n        // destroy() nulls the markers and a re-render replaces them, so a gate\n        // that opens after either one has nothing left to paint into\n        if (marker !== this.startMarker) return\n        this.endMarker!.parentNode!.insertBefore(renderNodes(this.template, templateScope, fx, shadow), this.endMarker!)\n        this.renderDone = true\n        this.settleMounted()\n      })\n      warnIfStuck(this, gates)\n    }\n\n    if (shadow) {\n      this.styleEls = this.styles.map(style => {\n        const el = document.createElement(\"style\")\n        el.textContent = style.content // the source: a shadow root scopes it already\n        return el\n      })\n    } else {\n      this.styles.forEach(style => acquireStyle(headStyle(style)))\n      this.ownsSharedStyles = true\n    }\n\n    return this\n  }\n\n  // renders (when needed) and attaches in one call: the component is rendered\n  // on the first mount, and re-rendered fresh whenever `data` is passed.\n  // mount(el) on an already-rendered component just re-attaches, keeping its\n  // state - the detach()/mount() round trip. Rendering here keeps whichever\n  // style mode was last used (document.head unless renderShadow/mountShadow\n  // chose a shadow root)\n  mount(parent: Element | ShadowRoot | DocumentFragment | string, data?: Record<string, any>): this {\n    const target = typeof parent === \"string\" ? $(parent) : parent\n    if (!target) throw new Error(`mount target not found: ${parent}`)\n    if (!this.content || data !== undefined) this.renderWith(data ?? {}, this.useShadow)\n    return this.attach(target)\n  }\n\n  // like mount(), but renders with styles scoped to a shadow root on the\n  // target instead of document.head\n  mountShadow(parent: Element | ShadowRoot | DocumentFragment | string, data?: Record<string, any>): this {\n    const target = typeof parent === \"string\" ? $(parent) : parent\n    if (!target) throw new Error(`mount target not found: ${parent}`)\n    if (!this.content || data !== undefined || !this.useShadow) this.renderWith(data ?? {}, true)\n    return this.attach(target)\n  }\n\n  private attach(target: Element | ShadowRoot | DocumentFragment): this {\n    if (this.mountRoot) this.detach()\n\n    const root = this.useShadow && target instanceof Element\n      ? target.shadowRoot ?? target.attachShadow({ mode: \"open\" })\n      : target\n    if (this.useShadow) this.styleEls.forEach(el => root.appendChild(el))\n    root.appendChild(this.content!)\n    this.mountRoot = root\n    this.settleMounted()\n    return this\n  }\n\n  // `await $mounted()` means \"rendered and on the page\", so it waits for both -\n  // whichever lands last calls this. In the ordinary synchronous flow the render\n  // is already done and this is the attach; for a component whose first render\n  // a script held back, it is the other way round\n  private settleMounted() {\n    if (this.renderDone && this.mountRoot) this.resolveMounted?.()\n  }\n\n  // detaches from the DOM while keeping all state; a later mount() re-attaches\n  // with any updates that happened while detached already applied\n  detach(): this {\n    if (!this.mountRoot || !this.content || !this.startMarker || !this.endMarker) return this\n\n    // move everything between the markers (inclusive) back into the holding\n    // fragment - including nodes :if/:each inserted after mounting\n    let node: Node | null = this.startMarker\n    while (node) {\n      const nextNode: Node | null = node.nextSibling\n      this.content.appendChild(node)\n      if (node === this.endMarker) break\n      node = nextNode\n    }\n\n    this.mountRoot = null\n    return this\n  }\n\n  destroy(): this {\n    this.detach()\n    this.fx?.dispose()\n    this.fx = null\n    // a store this component was handed (a shared `$reactive`) outlives it, and\n    // holds a listener per store that nested it - drop this instance's\n    this.data?.$dispose()\n    this.styleEls.forEach(el => el.parentNode?.removeChild(el))\n    this.styleEls = []\n    if (this.ownsSharedStyles) {\n      this.styles.forEach(style => releaseStyle(headStyle(style)))\n      this.ownsSharedStyles = false\n    }\n    this.content = null\n    this.startMarker = null\n    this.endMarker = null\n    this.renderDone = false\n    this.data = null\n    this.resolveMounted = null\n    return this\n  }\n}\n\n// what Component79.fetch() hands back: a component that hasn't arrived yet.\n//\n// Every method queues onto the fetch and returns the handle, so a whole page\n// is one expression and the calls run in the order they were written:\n//\n//   C79.fetch(\"./app.html\").on(\"save\", persist).mount(\"main\", { user })\n//\n// It is also thenable, resolving to the Component79 itself - which is what\n// keeps `await Component79.fetch(url)` (and importResource, and a handle\n// dropped into Promise.all) working exactly as before. Queued calls keep the\n// resolved value, so awaiting a chain gives the mounted component.\n//\n// The catch: mount() here returns the handle, not the component - there is no\n// component yet to return. That's why the whole lifecycle is on the handle and\n// not just mount(): nobody should have to await merely to destroy something.\nexport class PendingComponent79 {\n  // the fetch with every queued call chained onto it, each passing the\n  // component through - so `chain` always settles to the component, however\n  // many calls were queued, and a failure anywhere rejects the rest\n  private chain: Promise<Component79>\n\n  constructor(component: Promise<Component79>) {\n    this.chain = component\n  }\n\n  private queue(action: (component: Component79) => void): this {\n    this.chain = this.chain.then(component => {\n      action(component)\n      return component\n    })\n    return this\n  }\n\n  then<TResult1 = Component79, TResult2 = never>(\n    onfulfilled?: ((value: Component79) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult1 | TResult2> {\n    return this.chain.then(onfulfilled, onrejected)\n  }\n\n  // a chain nobody awaits reports a failed fetch as an unhandled rejection,\n  // like any dropped promise chain - these are for callers who'd rather handle\n  // it. catch() returns a promise, not a handle: the chain ends here\n  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<Component79 | TResult> {\n    return this.chain.catch(onrejected)\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<Component79> {\n    return this.chain.finally(onfinally)\n  }\n\n  mount(parent: Element | ShadowRoot | DocumentFragment | string, data?: Record<string, any>): this {\n    return this.queue(component => component.mount(parent, data))\n  }\n\n  mountShadow(parent: Element | ShadowRoot | DocumentFragment | string, data?: Record<string, any>): this {\n    return this.queue(component => component.mountShadow(parent, data))\n  }\n\n  render(data: Record<string, any> = {}): this {\n    return this.queue(component => component.render(data))\n  }\n\n  renderShadow(data: Record<string, any> = {}): this {\n    return this.queue(component => component.renderShadow(data))\n  }\n\n  on(eventName: string, listener: EmitListener): this {\n    return this.queue(component => component.on(eventName, listener))\n  }\n\n  off(eventName: string, listener: EmitListener): this {\n    return this.queue(component => component.off(eventName, listener))\n  }\n\n  detach(): this {\n    return this.queue(component => component.detach())\n  }\n\n  destroy(): this {\n    return this.queue(component => component.destroy())\n  }\n}\n\nexport { Component79 as C79 }\n\nexport const parseComponent = (component: string): Component79 => new Component79(component)\n\n// library helpers injected into setup scripts. They behave like extra\n// globals: a same-named scope property (render data or a top-level\n// declaration) shadows them\nconst SETUP_HELPERS: Record<string, any> = { $, $$, $create, $reactive, $toRaw, Component79 }\n\n// the hot-reload handshake. jq79/dev serves a classic script that sets the flag\n// below; classic scripts run before deferred module ones, so the flag is always\n// set before this module evaluates. The page's copy of the runtime can come from\n// anywhere - a CDN, an import map, dist/ - and the dev client has no way to\n// import *that* copy, so the runtime hands itself to the client instead\nif (typeof globalThis !== \"undefined\" && (globalThis as any)[HOT_FLAG]) enableHotReload()\n\n","// DOM helpers: tiny query/create utilities, also injected into component\n// scripts as $, $$ and $create\n\n// $(selector) queries the document; $(el, selector) queries within el. The\n// selector is required in the element form - an empty one is a SyntaxError\nexport function $(selector: string): Element | null\nexport function $(el: Element, selector: string): Element | null\nexport function $(selectorOrEl: string | Element, selector?: string): Element | null {\n  return typeof selectorOrEl === \"string\"\n    ? document.querySelector(selectorOrEl)\n    : selectorOrEl.querySelector(selector!)\n}\n\nexport function $$(selector: string): Element[]\nexport function $$(el: Element, selector: string): Element[]\nexport function $$(selectorOrEl: string | Element, selector?: string): Element[] {\n  return Array.from(\n    typeof selectorOrEl === \"string\"\n      ? document.querySelectorAll(selectorOrEl)\n      : selectorOrEl.querySelectorAll(selector!)\n  )\n}\n\n// $create(tag, attrs): attrs are set as attributes, except className, which\n// may be a string or an array of class names.\nexport const $create = (tag: string, attrs: Record<string, any> = {}): HTMLElement => {\n  const el = document.createElement(tag);\n  for (const [name, value] of Object.entries(attrs)) {\n    if (name === 'className') {\n      el.className = Array.isArray(value) ? value.join(' ') : value;\n    } else if (name === 'textContent') {\n      el.textContent = value;\n    } else if (name === 'children') {\n      for (const child of value) {\n        el.appendChild(child);\n      }\n    } else {\n      el.setAttribute(name, value);\n    }\n  }\n  return el;\n};\n\nconst ALLOWED_TAGS = new Set([\n  'a', 'b', 'i', 'em', 'strong', 'p', 'br', 'ul', 'ol', 'li',\n  'blockquote', 'code', 'pre', 'span', 'div', 'h1', 'h2', 'h3',\n  'h4', 'h5', 'h6', 'img'\n]);\n\nconst ALLOWED_ATTR: Record<string, Set<string>> = {\n  a: new Set(['href', 'title']),\n  img: new Set(['src', 'alt']),\n  '*': new Set(['class']), // atributos permitidos en cualquier tag\n};\n\nconst SAFE_URL_PROTOCOLS = new Set(['http:', 'https:', 'mailto:']);\n\nexport function isSafeUrl(value: string): boolean {\n  try {\n    // resolver relativo a algo neutro para poder leer el protocolo\n    const url = new URL(value, 'https://example.com');\n    return SAFE_URL_PROTOCOLS.has(url.protocol);\n  } catch {\n    return false;\n  }\n}\n\n// la política de destinos: decide si un href/src ya seguro por protocolo\n// puede apuntar a donde apunta. Restringe *sobre* el chequeo de protocolo,\n// nunca en su lugar\nexport type AllowUrl = (url: URL, tag: string, attr: string) => boolean;\n\nexport type SanitizeOptions = { allowUrl?: AllowUrl };\n\nconst DEFAULT_PORTS: Record<string, string> = { 'https:': '443', 'http:': '80' };\n\ntype HostPattern = { host: RegExp; port: string | null };\n\n// \"host[:puerto]\": `*` casa exactamente UNA etiqueta dns - la regla de los\n// certificados TLS, no la de CSP: *.germade.dev casa a.germade.dev, pero ni\n// germade.dev (escribe los dos para incluir el apex) ni a.b.germade.dev.\n// Sin puerto casa cualquiera; un patrón inválido devuelve null y no casa\n// nada - una política rota cierra, no abre\nfunction compileHostPattern(pattern: string): HostPattern | null {\n  const match = pattern.trim().toLowerCase().match(/^([a-z\\d*][a-z\\d.*-]*?)(?::(\\d{1,5}|\\*))?$/);\n  if (!match) return null;\n  const [, host, port] = match;\n  const labels = host.split('.');\n  if (labels.some(label => label !== '*' && !/^[a-z\\d-]+$/.test(label))) return null;\n  // las etiquetas validadas no llevan metacaracteres de regex, así que no\n  // hay nada que escapar; los puntos los pone el join\n  const re = new RegExp(`^${labels.map(label => (label === '*' ? '[^.]+' : label)).join('\\\\.')}$`);\n  return { host: re, port: !port || port === '*' ? null : port };\n}\n\n// compila una lista de patrones (string separado por comas, o array) en un\n// predicado AllowUrl. El puerto comparado es el *efectivo* de la URL (el\n// explícito, o el del esquema), así \"germade.dev:443\" casa https://germade.dev.\n// Una URL sin host (mailto:) no casa ningún patrón: los patrones hablan de\n// hosts - la forma función de la política puede admitirla si quiere\nexport const allowedHosts = (patterns: string | string[]): AllowUrl => {\n  const compiled = (Array.isArray(patterns) ? patterns : patterns.split(','))\n    .map(compileHostPattern)\n    .filter((p): p is HostPattern => p !== null);\n  return url => {\n    const host = url.hostname.toLowerCase();\n    const port = url.port || DEFAULT_PORTS[url.protocol] || '';\n    return compiled.some(p => p.host.test(host) && (p.port === null || p.port === port));\n  };\n};\n\n// consulta la política con la URL resuelta contra la página, para que una\n// URL relativa se juzgue como el destino same-origin que realmente es. Un\n// predicado que lanza, o una URL que no parsea, es un no\nfunction consultAllowUrl(allowUrl: AllowUrl, value: string, tag: string, attr: string): boolean {\n  try {\n    return !!allowUrl(new URL(value, document.baseURI), tag, attr);\n  } catch {\n    return false;\n  }\n}\n\n// el saneado es recursivo, así que la profundidad del input es profundidad\n// de pila. 512 es lo que toleran los parsers de los navegadores antes de\n// aplanar el anidamiento, con lo que ningún documento legítimo pierde nada -\n// y superar el límite lanza un RangeError con nombre, en vez de reventar la\n// pila en algún punto indeterminado más arriba\nconst MAX_SANITIZE_DEPTH = 512;\n\n// copia los hijos de `source` en `target`, saneando los elementos y clonando\n// el texto; cualquier otra cosa (comentarios, etc.) se descarta\nfunction appendSanitizedChildren(source: ParentNode, target: HTMLElement, depth: number, allowUrl?: AllowUrl): void {\n  if (depth > MAX_SANITIZE_DEPTH) {\n    throw new RangeError(`jq79: sanitizeHTML input nests deeper than ${MAX_SANITIZE_DEPTH} elements`);\n  }\n  for (const child of Array.from(source.childNodes)) {\n    if (child.nodeType === Node.ELEMENT_NODE) {\n      const sanitizedChild = sanitizeNode(child as HTMLElement, depth, allowUrl);\n      if (sanitizedChild) target.appendChild(sanitizedChild);\n    } else if (child.nodeType === Node.TEXT_NODE) {\n      target.appendChild(child.cloneNode());\n    }\n  }\n}\n\n// sanea un elemento (los llamadores solo pasan nodos ELEMENT_NODE)\nfunction sanitizeNode(node: HTMLElement, depth: number, allowUrl?: AllowUrl): HTMLElement | null {\n  const tag = node.tagName.toLowerCase();\n  if (!ALLOWED_TAGS.has(tag)) return null; // tag no permitido → se descarta el nodo entero\n\n  const clean = document.createElement(tag);\n\n  for (const attr of Array.from(node.attributes)) {\n    const name = attr.name.toLowerCase();\n    const allowedForTag = ALLOWED_ATTR[tag]?.has(name);\n    const allowedGlobal = ALLOWED_ATTR['*']?.has(name);\n    if (!allowedForTag && !allowedGlobal) continue;\n\n    if (name === 'href' || name === 'src') {\n      if (!isSafeUrl(attr.value)) continue;\n      if (allowUrl && !consultAllowUrl(allowUrl, attr.value, tag, name)) continue;\n    }\n\n    clean.setAttribute(name, attr.value);\n  }\n\n  // fuerza rel seguro en enlaces (target nunca se copia: no está permitido)\n  if (tag === 'a') clean.setAttribute('rel', 'noopener noreferrer');\n\n  appendSanitizedChildren(node, clean, depth + 1, allowUrl);\n\n  return clean;\n}\n\nexport function sanitizeHTML(html: string, options?: SanitizeOptions): string {\n  // parsear con <template> en vez de con DOMParser: el contenido de un template\n  // es un documento inerte igual (ni scripts ni imágenes se ejecutan al asignar\n  // innerHTML), pero el parseo de fragmento conserva el espacio en blanco inicial\n  // que el modo \"before body\" de un documento completo descartaría - así una\n  // primera línea indentada (un diff, un <pre>) llega con su sangría intacta\n  const template = document.createElement('template');\n  template.innerHTML = html;\n  const container = document.createElement('div');\n\n  appendSanitizedChildren(template.content, container, 0, options?.allowUrl);\n\n  return container.innerHTML;\n}","// the reactive store ($reactive): proxy-based deep reactivity with\n// dot-path dependency tracking, plus the effect-scope helper the renderer\n// uses to tear down a subtree's bindings in one call\n\ntype ChangeListener = (value: any, dotKey: string) => void\ntype AnyChangeListener = (dotKey: string, value: any) => void\ntype ListenerOptions = { immediate?: boolean }\ntype Unsubscribe = () => void\n\nexport type ReactiveDeepData<T> = T & {\n  $on: (dotKey: string, listener: ChangeListener, options?: ListenerOptions) => Unsubscribe\n  $onAny: (listener: AnyChangeListener, options?: ListenerOptions) => Unsubscribe\n  // runs `run` immediately, recording every dotKey it reads off this store, then\n  // re-runs it whenever a changed dotKey overlaps one of those - see pathsOverlap.\n  // `alsoWakenBy` registers the same effect with other stores as well, so a\n  // change in any of them wakes it too (see ATTACH)\n  $effect: (run: () => void, alsoWakenBy?: Record<string, any>[]) => Unsubscribe\n  // drops this store's subscriptions to the stores nested inside it (see\n  // bridge). A store that outlives the one holding it - the shared-state case -\n  // would otherwise keep the dead holder's listeners on its own list forever\n  $dispose: () => void\n}\n\nconst getByPath = (obj: Record<string, any>, dotKey: string): any =>\n  dotKey.split(\".\").reduce((acc, key) => (acc == null ? undefined : acc[key]), obj)\n\n// only plain objects and arrays get deep-wrapped by the reactive store;\n// class instances (Component79, Date, DOM nodes, ...) pass through untouched\n// so their identity, prototypes and internals stay intact\nconst isPlainData = (value: object): boolean => {\n  if (Array.isArray(value)) return true\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n\nconst walkLeaves = (obj: Record<string, any>, path: string, visit: (dotKey: string, value: any) => void) => {\n  Object.entries(obj).forEach(([key, value]) => {\n    const dotKey = path ? `${path}.${key}` : key\n    if (value && typeof value === \"object\" && isPlainData(value)) walkLeaves(value, dotKey, visit)\n    else visit(dotKey, value)\n  })\n}\n\n// true when `a` and `b` sit on the same ancestor/descendant line, e.g.\n// \"user\" & \"user.address.city\" (a change to either affects the other) - false\n// for siblings like \"user.name\" & \"user.age\"\nconst pathsOverlap = (a: string, b: string): boolean =>\n  a === b || a.startsWith(`${b}.`) || b.startsWith(`${a}.`)\n\n// reads the raw object behind a store proxy. Module-level (not per-store) so a\n// value that is already reactive - in this store or in another one - can be\n// unwrapped before being wrapped again. Without it, handing the same object to\n// two stores has each one wrapping the other's proxies, and since a wrap walks\n// what it wraps, the nesting compounds until the process stops responding\nconst RAW = Symbol(\"jq79.raw\")\n\n// a free function rather than a method on the store, because the store API is\n// served from the root proxy alone (see storeApi): `store.$toRaw()` would work\n// and `store.user.$toRaw()` would not, which is the case callers actually have.\n// The RAW symbol travels on every proxy at every depth, so this works anywhere.\n// What it returns is the real object, not a copy: writes to it notify nobody\nexport const $toRaw = <T>(value: T): T => {\n  let raw: any = value\n  while (raw !== null && typeof raw === \"object\" && raw[RAW]) raw = raw[RAW]\n  return raw\n}\n\n// marks a store's *root* proxy. A store put inside another store (a setup\n// script's `const local = $reactive(...)`) has to pass through whole: it owns\n// its listeners and its $on/$effect, so unwrapping it would strip away the very\n// thing it is. Nested proxies carry no such marker and are unwrapped freely\nconst STORE = Symbol(\"jq79.store\")\n\nconst isStore = (value: any): boolean =>\n  value !== null && typeof value === \"object\" && value[STORE] === true\n\n// active $effect() runs, innermost last - a module-level stack (rather than\n// one per store) so nested effects across stores still nest correctly; reads\n// during a proxy's `get` trap are attributed to whichever run is on top\nconst trackerStack: Set<string>[] = []\n\n// runs fn with dependency tracking suspended - reads inside it are attributed\n// to a throwaway set instead of the currently running effect\nexport const untracked = <T>(fn: () => T): T => {\n  trackerStack.push(new Set())\n  try {\n    return fn()\n  } finally {\n    trackerStack.pop()\n  }\n}\n\ntype Effect = { deps: Set<string>; run: () => void }\n\n// an effect lives in exactly one store's `effects` set - the one whose\n// $effect created it - and only that store's notify walks it. Content that\n// reads two stores at once (a component's slot content: the parent's names\n// plus the slot props the child passes it) needs one record in both sets, so\n// a store serves this attach handle beside $on/$effect. Tracking already\n// spans stores - trackerStack is module-level, so one run's deps are whatever\n// it read, wherever it read it - only the waking didn't.\n//\n// Named like the compiled scripts' internals ($__effect, $__import) because it\n// is one: `key in store` never answers true for a storeApi name, so `with`\n// can't see it and no template expression can reach it.\n//\n// The cost, accepted: deps are dot-paths with no store namespace, so a name\n// that exists in both stores wakes the effect from either. A spurious re-run,\n// never a stale render\nconst ATTACH = \"$__attach\"\n\n// the extra stores every effect created off a scope must be attached to. Read\n// by createEffectScope off the scope it is given, so a scope can hand the\n// arrangement down to whatever renders inside it (nested :each item scopes,\n// a nested component's prop-sync effects) without every call site knowing\nexport const ALSO_WAKEN_BY = Symbol(\"jq79.alsoWakenBy\")\n\nexport const $reactive = <T extends Record<string, any>>(data: T): ReactiveDeepData<T> => {\n  const exactListeners = new Map<string, Set<ChangeListener>>()\n  const anyListeners = new Set<AnyChangeListener>()\n  const effects = new Set<Effect>()\n\n  // one proxy per raw object, for this store alone. Keyed by the *raw object*\n  // rather than by its path, so identity travels with the object: :each diffs\n  // its items by reference (Object.is), and a reordered list has to hand back\n  // the same proxy for the same item or every row would re-render. The flip\n  // side is that an object's path is fixed when it is first wrapped, so after a\n  // reorder its notifications carry the old index - effects that read the list\n  // itself still wake up (pathsOverlap), which is what makes it a non-issue in\n  // practice\n  const proxies = new WeakMap<object, Record<string, any>>()\n\n  // $on/$onAny/$effect are served from the root proxy's `get` instead of being\n  // defined on the object: a store must leave nothing behind on the data it was\n  // handed, and two stores over one object would otherwise clobber each other's\n  // handles. Null-prototype, so `key in storeApi` can't match Object.prototype\n  const storeApi: Record<string, any> = Object.create(null)\n\n  const notify = (dotKey: string, value: any, isNewKey = false) => {\n    exactListeners.get(dotKey)?.forEach(listener => listener(value, dotKey))\n    anyListeners.forEach(listener => listener(dotKey, value))\n    effects.forEach(effect => {\n      // a newly-created key re-runs every effect: an effect that read the\n      // name while it didn't exist couldn't track it (`with` skipped the\n      // store entirely), so dep matching would never wake it up\n      if (isNewKey || Array.from(effect.deps).some(dep => pathsOverlap(dep, dotKey))) effect.run()\n    })\n  }\n\n  const isWrappable = (value: any): value is Record<string, any> =>\n    value !== null && typeof value === \"object\" && isPlainData(value)\n\n  // a store nested inside this one keeps its own listeners and its own effects,\n  // and this store's effects are not among them - so a write through the inner\n  // store notifies nobody out here, and a component rendering `{{ cart.items }}`\n  // off a `$reactive` it was handed would never update. The holder subscribes\n  // instead, and re-notifies the inner store's changes under the path it sits at\n  // (\"items.0\" -> \"cart.items.0\"). An effect that read through `cart` recorded\n  // exactly that path's ancestor as a dependency, so pathsOverlap wakes it.\n  // Chains compose: re-notifying runs this store's own $onAny listeners, which\n  // is how a store two levels down still reaches the top\n  const bridges = new Map<string, { store: any; unsubscribe: Unsubscribe }>()\n\n  const bridge = (store: any, path: string) => {\n    const current = bridges.get(path)\n    if (current?.store === store) return\n    current?.unsubscribe()\n    bridges.set(path, {\n      store,\n      unsubscribe: store.$onAny((dotKey: string, value: any) => notify(`${path}.${dotKey}`, value)),\n    })\n  }\n\n  // the key no longer holds the store it held: stop listening to it\n  const unbridge = (path: string) => {\n    bridges.get(path)?.unsubscribe()\n    bridges.delete(path)\n  }\n\n  // the reactive view of `raw`, created on demand. Callers must hand it a raw\n  // object (see $toRaw at both call sites): wrapping a proxy is what compounds\n  const wrap = (raw: Record<string, any>, path: string): Record<string, any> => {\n    const cached = proxies.get(raw)\n    if (cached) return cached\n\n    // keys that were deleted off this object. `with ($scope)` resolves a name\n    // through [[HasProperty]], so without a claim here a deleted key would fall\n    // through to globalThis and the *whole* expression would die of\n    // ReferenceError - `user ? user.name : \"none\"` must take its else branch\n    // instead. The cost: `\"user\" in store` stays true after a delete\n    let tombstones: Set<string> | null = null\n\n    const proxy: Record<string, any> = new Proxy(raw, {\n      has(target, key) {\n        return Reflect.has(target, key) || (typeof key === \"string\" && tombstones?.has(key) === true)\n      },\n      get(target, key, receiver) {\n        if (key === RAW) return target\n        if (key === STORE) return path === \"\"\n        if (typeof key !== \"string\") return Reflect.get(target, key, receiver)\n        if (path === \"\" && key in storeApi) return storeApi[key]\n\n        const dotKey = path ? `${path}.${key}` : key\n        trackerStack[trackerStack.length - 1]?.add(dotKey)\n\n        // nested objects are wrapped here rather than up front, so the object\n        // handed to $reactive is never rewritten\n        const value = Reflect.get(target, key, receiver)\n        if (isStore(value)) {\n          bridge(value, dotKey)\n          return value\n        }\n\n        const raw = $toRaw(value)\n        return isWrappable(raw) ? wrap(raw, dotKey) : raw\n      },\n      set(target, key: string, value, receiver) {\n        // an assignment delegated up the prototype chain from a derived scope\n        // (Object.create(store) child, or a wrapping proxy): if the key isn't\n        // a real property of this store, honor the receiver so the new binding\n        // lands on the derived scope - a scope-local variable, not a store\n        // mutation, so no notify. If the key IS a store property, fall through\n        // and mutate the store itself regardless of receiver, so assignments\n        // like @click=\"count = count + 1\" work from any nested scope\n        if (receiver !== proxy && !Object.prototype.hasOwnProperty.call(target, key)) {\n          return Reflect.set(target, key, value, receiver)\n        }\n\n        const dotKey = path ? `${path}.${key}` : key\n        // store the raw value, never a proxy - including one of our own, so\n        // that `list = [list[1], list[0]]` doesn't write proxies back into the\n        // data. Reads re-wrap it, from the cache, as the very same proxy. A\n        // whole store assigned in is the exception: it stays as it is\n        const stored = isStore(value) ? value : $toRaw(value)\n        const isNewKey = !Object.prototype.hasOwnProperty.call(target, key)\n        // a primitive write that changes nothing notifies nobody: it's what\n        // lets an effect write the value it just read (a normalizing\n        // assignment, a prop sync) and settle instead of waking itself\n        // forever. Only primitives and functions: re-writing the SAME object\n        // reference stays loud, because that is the cross-store \"deep touch\"\n        // channel - a parent's prop sync forwards `user.name = x` to the\n        // child's store by re-assigning the same `user`, and the child's\n        // listeners live on the child's store, not the parent's. A new key\n        // always announces itself - the sweep is its whole point\n        if (!isNewKey && Object.is(target[key], stored) && (stored === null || typeof stored !== \"object\")) return true\n        target[key] = stored\n        tombstones?.delete(key) // the key exists again: no claim needed\n        if (isStore(stored)) bridge(stored, dotKey)\n        else unbridge(dotKey)\n        const notified = isStore(stored) || !isWrappable(stored) ? stored : wrap(stored, dotKey)\n        notify(dotKey, notified, isNewKey)\n        return true\n      },\n      // `delete data.user` is a plain-object mutation like any other, so it\n      // notifies like one - with `undefined`, which is what a read returns\n      // afterwards. Array methods that shrink (pop, splice) delete their dead\n      // slots through this trap too. No new-key sweep: whoever depended on the\n      // key tracked it while it existed, so dep matching wakes exactly them\n      deleteProperty(target, key) {\n        if (typeof key !== \"string\") return Reflect.deleteProperty(target, key)\n        const had = Object.prototype.hasOwnProperty.call(target, key)\n        const deleted = Reflect.deleteProperty(target, key)\n        if (deleted && had) {\n          const dotKey = path ? `${path}.${key}` : key\n          ;(tombstones ??= new Set()).add(key)\n          unbridge(dotKey) // a nested store it held: stop listening to it\n          notify(dotKey, undefined)\n        }\n        return deleted\n      }\n    })\n\n    proxies.set(raw, proxy)\n    return proxy\n  }\n\n  const reactive = wrap($toRaw(data), \"\") as ReactiveDeepData<T>\n\n  // a store handed in with the data (a prop, or render data) is bridged here\n  // rather than on first read, so a listener registered before anything reads\n  // the key still hears it. Only the top level is scanned: that's where a prop\n  // lands, and descending would mean walking whatever else was handed in - a\n  // highlighter, an API client - to its leaves. A store sitting deeper is\n  // bridged when the read that reaches it wraps its parent\n  Object.entries($toRaw(data)).forEach(([key, value]) => {\n    if (isStore(value)) bridge(value, key)\n  })\n\n  const $on = (dotKey: string, listener: ChangeListener, { immediate = false }: ListenerOptions = {}): Unsubscribe => {\n    if (!exactListeners.has(dotKey)) exactListeners.set(dotKey, new Set())\n    exactListeners.get(dotKey)!.add(listener)\n    if (immediate) listener(getByPath(reactive, dotKey), dotKey)\n    return () => exactListeners.get(dotKey)?.delete(listener)\n  }\n\n  const $onAny = (listener: AnyChangeListener, { immediate = false }: ListenerOptions = {}): Unsubscribe => {\n    anyListeners.add(listener)\n    if (immediate) walkLeaves(reactive, \"\", (dotKey, value) => listener(dotKey, value))\n    return () => anyListeners.delete(listener)\n  }\n\n  const $effect = (run: () => void, alsoWakenBy?: Record<string, any>[]): Unsubscribe => {\n    // a notify landing while this effect runs (an item's render writing to\n    // the store, waking the very effect that is rendering it) must not\n    // re-enter mid-run - the half-done run would race its own repeat over\n    // shared state, which is how :each once tripled its rows. It marks the\n    // run dirty instead, and repeats *after* it finishes, against settled\n    // state, until clean. Still fully synchronous: everything happens before\n    // the triggering assignment returns\n    let running = false\n    let dirty = false\n    const effect: Effect = {\n      deps: new Set(),\n      run: () => {\n        if (running) {\n          dirty = true\n          return\n        }\n        running = true\n        try {\n          let cycles = 0\n          do {\n            dirty = false\n            const deps = new Set<string>()\n            trackerStack.push(deps)\n            try {\n              run()\n            } finally {\n              trackerStack.pop()\n              effect.deps = deps\n            }\n          } while (dirty && ++cycles < 100)\n          // an effect that keeps writing its own dependencies used to die by\n          // stack overflow; now it is cut off and named\n          if (dirty) console.error(\"jq79: an effect re-woke itself 100 times in a row (it writes what it reads); giving up on it settling\")\n        } finally {\n          running = false\n        }\n      },\n    }\n    effects.add(effect)\n    // the shared case is rare (only slot content asks for it) and this\n    // function is on the stack for as long as whatever it renders - a\n    // component that renders itself stacks 200 of these - so it keeps the\n    // shape it had, and the extra bookkeeping lives in its own frame\n    if (alsoWakenBy?.length) return attachAndRun(effect, alsoWakenBy)\n    effect.run()\n    return () => { effects.delete(effect) }\n  }\n\n  // attached before the first run, so a store that notifies during it (a setup\n  // script's write, a prop sync) reaches this effect like any other\n  const attachAndRun = (effect: Effect, alsoWakenBy: Record<string, any>[]): Unsubscribe => {\n    const detach = alsoWakenBy.map(store => store?.[ATTACH]?.(effect)).filter(Boolean) as Unsubscribe[]\n    effect.run()\n    return () => {\n      effects.delete(effect)\n      detach.forEach(drop => drop())\n    }\n  }\n\n  const $__attach = (effect: Effect): Unsubscribe => {\n    effects.add(effect)\n    return () => { effects.delete(effect) }\n  }\n\n  const $dispose = () => {\n    bridges.forEach(({ unsubscribe }) => unsubscribe())\n    bridges.clear()\n  }\n\n  storeApi.$on = $on\n  storeApi.$onAny = $onAny\n  storeApi.$effect = $effect\n  storeApi.$dispose = $dispose\n  storeApi[ATTACH] = $__attach\n\n  return reactive\n}\n// groups the disposers of every $effect created for one rendered subtree\n// (an :if branch, an :each item, ...) so the whole subtree's bindings can be\n// torn down in one call when that subtree is replaced/removed. `scope.$effect`\n// resolves through the prototype chain up to the root store no matter how\n// many nested :each scopes sit in between (see renderEach's itemScope)\nexport type EffectScope = {\n  effect: (run: () => void) => void\n  // registers an arbitrary cleanup (e.g. destroying a nested component) to\n  // run when this subtree is torn down\n  onDispose: (fn: Unsubscribe) => void\n  // re-runs every effect registered on this scope, nested scopes excluded:\n  // how :each tells a reused, repositioned entry's dep-less bindings (the\n  // `{{ $index }}`-only case) about their move. Deps stay as they were -\n  // callers run it untracked\n  refresh: () => void\n  dispose: () => void\n}\n\nexport const createEffectScope = (scope: Record<string, any>): EffectScope => {\n  const disposers: Unsubscribe[] = []\n  const runs: (() => void)[] = []\n  // whatever the scope was handed (slot content is the only thing that sets\n  // it today): the stores this scope's effects belong to besides their own.\n  // Left undefined when there are none, which is $effect's fast path\n  const alsoWakenBy: Record<string, any>[] | undefined = (scope as any)[ALSO_WAKEN_BY]\n  return {\n    effect: run => {\n      disposers.push(scope.$effect(run, alsoWakenBy))\n      runs.push(run)\n    },\n    onDispose: fn => { disposers.push(fn) },\n    refresh: () => { runs.forEach(run => run()) },\n    dispose: () => {\n      disposers.splice(0).forEach(dispose => dispose())\n      runs.length = 0\n    },\n  }\n}\n","// ---------------------------------------------------------------------------\n// :setup script transform\n//\n// setup scripts are written like Svelte components:\n//\n//   let firstName = null\n//   $: fullName = `${firstName} ${lastName}`\n//   fetchUser().then(user => { firstName = user.firstName })\n//\n// and are executed inside `with ($scope)` against the component's reactive\n// store, so plain assignments (even from async callbacks) go through the\n// proxy's set trap and re-render whatever depends on them. To make that work\n// the source is lightly rewritten - no full JS parser, just a scanner that is\n// string/comment-aware and only touches code at brace/paren depth 0:\n// - `let/var/const x = ...` at the top level loses its keyword, becoming a\n//   scope assignment (the name is pre-declared on the store so the `with`\n//   lookup resolves it)\n// - `$: x = expr` becomes `$__effect(() => { x = expr })`, re-running when a\n//   dependency read inside expr changes ($__effect is deliberately NOT a\n//   property of the scope, so `with` falls through to the function parameter)\n// ---------------------------------------------------------------------------\n\ntype SetupTransform = { vars: string[]; code: string }\n\n// a declaration whose target is an identifier (`let x`), an object pattern\n// (`let { a }`, space optional) or an array pattern (`let [x]`)\nconst DECLARATION_START_RE = /(?:let|var|const)(?:\\s+(?=[A-Za-z_$])|\\s*(?=[{[]))/y\nconst REACTIVE_LABEL_RE = /\\$:\\s*/y\nconst IMPORT_CALL_RE = /import(?=\\s*\\()/y\nconst REACTIVE_ASSIGN_RE = /\\$:\\s*([A-Za-z_$][\\w$]*)\\s*=(?!=)/y\n\nconst skipString = (src: string, start: number): number => {\n  const quote = src[start]\n  let i = start + 1\n  while (i < src.length) {\n    if (src[i] === \"\\\\\") { i += 2; continue }\n    if (src[i] === quote) return i + 1\n    i++\n  }\n  return src.length\n}\n\nconst skipLineComment = (src: string, start: number): number => {\n  const end = src.indexOf(\"\\n\", start)\n  return end === -1 ? src.length : end\n}\n\nconst skipBlockComment = (src: string, start: number): number => {\n  const end = src.indexOf(\"*/\", start + 2)\n  return end === -1 ? src.length : end + 2\n}\n\n// index of the next thing that isn't whitespace or a comment\nconst skipToToken = (src: string, start: number): number => {\n  let i = start\n  while (i < src.length) {\n    if (/\\s/.test(src[i])) { i++; continue }\n    if (src[i] === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (src[i] === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    break\n  }\n  return i\n}\n\n// ---------------------------------------------------------------------------\n// regex literals. The scanners walk the source counting bracket depth, and a\n// regex walked as if it were code poisons that count: `split(/\\//)` puts two\n// slashes side by side (a line comment, as far as a scanner knows) and the\n// `)` after them is skipped uncounted; `/[(]/` inflates the depth for good.\n// So a `/` that opens a regex is consumed whole - and whether it opens one is\n// the classic lexer call, made the way every tokenizer makes it: by what came\n// before. Division needs a completed expression on its left; everywhere else\n// a `/` can only be a regex.\n// ---------------------------------------------------------------------------\n\n// reserved words a regex can follow. Reserved only - `of` is not (`const of\n// = 4; of / 2` is legal division), so `for (x of /re/)` stays unrescued\n// rather than risking real code\nconst REGEX_AFTER_WORD = new Set([\n  \"return\", \"typeof\", \"case\", \"in\", \"instanceof\", \"new\", \"delete\", \"void\", \"do\", \"else\", \"yield\", \"await\",\n])\n\n// whether a `/` at `at` opens a regex literal rather than a division: looks\n// backward past whitespace and block comments for the last meaningful thing.\n// A completed expression - identifier, number, closing quote or bracket,\n// postfix ++/-- - takes division; a reserved word or any other punctuator\n// admits a regex. Only consulted for the rare `/` that is neither `//` nor\n// `/*`, so the scanners pay nothing on the common path\nconst regexAllowed = (src: string, at: number): boolean => {\n  let i = at - 1\n  while (i >= 0) {\n    const ch = src[i]\n    if (/\\s/.test(ch)) { i--; continue }\n    if (ch === \"/\" && src[i - 1] === \"*\") {\n      const open = src.lastIndexOf(\"/*\", i - 2)\n      if (open === -1) return true // an unopened comment tail: malformed input\n      i = open - 1\n      continue\n    }\n    break\n  }\n  if (i < 0) return true // the start of the source starts an expression\n  const ch = src[i]\n  if (/[\\w$]/.test(ch)) {\n    let start = i\n    while (start > 0 && /[\\w$]/.test(src[start - 1])) start--\n    return REGEX_AFTER_WORD.has(src.slice(start, i + 1))\n  }\n  if ((ch === \"+\" || ch === \"-\") && src[i - 1] === ch) return false // postfix ++/--\n  return !\")]}\\\"'`.\".includes(ch)\n}\n\n// consumes a regex literal (with its flags): backslash escapes, and character\n// classes, where an unescaped `/` doesn't close the literal (`/[/]/` is one\n// regex). A literal can't contain an unescaped newline, so hitting one means\n// the classification was wrong or the input malformed - stop there, bounding\n// any damage to a single line\nconst skipRegex = (src: string, start: number): number => {\n  let i = start + 1\n  let inClass = false\n  while (i < src.length) {\n    const ch = src[i]\n    if (ch === \"\\\\\") { i += 2; continue }\n    if (ch === \"\\n\") return i\n    if (ch === \"[\") inClass = true\n    else if (ch === \"]\") inClass = false\n    else if (ch === \"/\" && !inClass) {\n      i++\n      while (i < src.length && /[a-z]/i.test(src[i])) i++ // flags\n      return i\n    }\n    i++\n  }\n  return src.length\n}\n\n// tokens that can't *start* a statement, so a line beginning with one is\n// continuing the previous expression rather than opening a new statement -\n// the same call JS's automatic semicolon insertion makes. Unary-only forms\n// (!, ~, ++, --) are deliberately absent: those do start a statement, and JS\n// inserts the semicolon before them\nconst CONTINUATION_RE = /^(\\?\\.|\\?\\?|&&|\\|\\||\\*\\*|[.,+\\-*/%&|^<>=?:([])/\n\n// the last meaningful character before `at`: walks back past whitespace and\n// block comments, the way regexAllowed does. A line comment can't be skipped\n// from behind (its start is only findable forwards), so a line ending in one\n// reports the comment's text instead - callers treat that as \"not the char I\n// was looking for\", which degrades to ending the statement, exactly as\n// before this helper existed\nconst lastMeaningfulBefore = (src: string, at: number): string => {\n  let i = at - 1\n  while (i >= 0) {\n    const ch = src[i]\n    if (/\\s/.test(ch)) { i--; continue }\n    if (ch === \"/\" && src[i - 1] === \"*\") {\n      const open = src.lastIndexOf(\"/*\", i - 2)\n      if (open === -1) return \"\"\n      i = open - 1\n      continue\n    }\n    return ch\n  }\n  return \"\"\n}\n\n// end of a statement starting at `start`: the first `;` or line break that\n// isn't inside a string/comment or unbalanced brackets. A line break only\n// ends the statement if the next line can't continue it, so leading-dot\n// method chains and multi-line operator chains stay in one piece:\n//\n//   $: total = items\n//     .filter(item => item.active)      <- still the same statement\n//     .length\n//\n// ...and only if the current line *can* end it: a line whose last meaningful\n// character is `,` or `=` left its expression incomplete (a multi-line\n// declarator list writes exactly this), so the statement continues - the\n// same ASI call as the leading-token check, made from the other side\nconst findStatementEnd = (src: string, start: number): number => {\n  let depth = 0\n  let i = start\n  while (i < src.length) {\n    const ch = src[i]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { i = skipString(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (ch === \"/\" && regexAllowed(src, i)) { i = skipRegex(src, i); continue }\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch)) depth--\n    else if (depth <= 0 && ch === \";\") return i\n    else if (depth <= 0 && ch === \"\\n\") {\n      const next = skipToToken(src, i + 1)\n      const continues =\n        next < src.length &&\n        (CONTINUATION_RE.test(src.slice(next, next + 2)) || [\",\", \"=\"].includes(lastMeaningfulBefore(src, i)))\n      if (!continues) return i\n      i = next\n      continue\n    }\n    i++\n  }\n  return src.length\n}\n\n// ---------------------------------------------------------------------------\n// top-level declarations. `let x = 1` loses its keyword and becomes a scope\n// assignment (x pre-declared on the store). A destructuring declarator\n// becomes an *assignment pattern*: inside `with`, `({ a, b } = obj)` writes\n// every binding through the reactive proxy - which is what makes it reactive.\n// The parens keep the `{` from opening a block, and a leading `;` keeps the\n// `(` from gluing onto the previous line as a call. Multi-declarator\n// statements (`let a = 1, b = 2`) register every binding, not just the first.\n// These lean on the pattern helpers defined with the props signature below\n// (splitTopLevel, indexOfTopLevel, defaultAssignIndex); the scanner only\n// runs long after the module evaluates, so the order is cosmetic\n// ---------------------------------------------------------------------------\n\ntype Declarator = { raw: string; codeEnd: number }\n\n// splits a declarator list at top-level commas, keeping each segment's raw\n// text (layout and comments included) and where its last meaningful token\n// ends - the spot a closing paren must go, so a trailing comment can't\n// swallow it\nconst splitDeclarators = (src: string): Declarator[] => {\n  const parts: Declarator[] = []\n  let depth = 0\n  let start = 0\n  let lastEnd = 0\n  const flush = (end: number) => {\n    parts.push({ raw: src.slice(start, end), codeEnd: Math.max(0, lastEnd - start) })\n    start = end + 1\n    lastEnd = start\n  }\n  let i = 0\n  while (i < src.length) {\n    const ch = src[i]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { i = skipString(src, i); lastEnd = i; continue }\n    if (ch === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (ch === \"/\" && regexAllowed(src, i)) { i = skipRegex(src, i); lastEnd = i; continue }\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch)) depth--\n    else if (ch === \",\" && depth <= 0) { flush(i); i++; continue }\n    if (!/\\s/.test(ch)) lastEnd = i + 1\n    i++\n  }\n  flush(src.length)\n  return parts\n}\n\n// the *binding* names a destructuring pattern declares - unlike\n// parsePropsPattern, which answers \"which props\" (the keys), this answers\n// \"which variables\": `{ a: x }` binds x, `{ a: { b } }` binds b,\n// `[x, ...rest]` binds x and rest. Defaults are stripped; what remains is a\n// nested pattern (recurse) or the bound identifier\nconst patternBindings = (src: string): string[] => {\n  const pattern = src.trim()\n  if (!pattern.startsWith(\"{\") && !pattern.startsWith(\"[\")) {\n    return IDENTIFIER_RE.test(pattern) ? [pattern] : []\n  }\n  const names: string[] = []\n  for (let part of splitTopLevel(pattern.slice(1, patternCloseIndex(pattern)))) {\n    if (part.startsWith(\"...\")) part = part.slice(3).trim()\n    const assign = defaultAssignIndex(part)\n    if (assign !== -1) part = part.slice(0, assign).trim()\n    if (pattern.startsWith(\"{\")) {\n      const colon = indexOfTopLevel(part, \":\")\n      if (colon !== -1) {\n        names.push(...patternBindings(part.slice(colon + 1)))\n        continue\n      }\n    }\n    names.push(...patternBindings(part))\n  }\n  return names\n}\n\n// one `let/var/const` declarator list, rewritten to scope assignments.\n// Each segment's initializer is re-scanned so an `import()` inside it is\n// rewritten like anywhere else - nothing else can match in there, since a\n// nested top-level declaration inside a declarator is a SyntaxError in JS\nconst rewriteDeclarators = (src: string): SetupTransform => {\n  const vars: string[] = []\n  const rewritten = splitDeclarators(src).map(({ raw, codeEnd }) => {\n    const lead = raw.match(/^\\s*/)![0]\n    if (codeEnd <= lead.length) return { text: raw, empty: true }\n    const body = raw.slice(lead.length, codeEnd)\n    const tail = raw.slice(codeEnd)\n    const assign = defaultAssignIndex(body)\n    const target = (assign === -1 ? body : body.slice(0, assign)).trim()\n    const isPattern = body[0] === \"{\" || body[0] === \"[\"\n    if (isPattern) vars.push(...patternBindings(target))\n    else if (IDENTIFIER_RE.test(target)) vars.push(target)\n    const code = transformSetupScript(body).code\n    return { text: `${lead}${isPattern ? `(${code})` : code}${tail}`, empty: false }\n  })\n\n  // a trailing comment-only segment (`let a = 1, // note` cut at its line\n  // end) is re-attached without its comma, so the output stays a statement\n  const tail: string[] = []\n  while (rewritten.length && rewritten[rewritten.length - 1].empty) tail.unshift(rewritten.pop()!.text)\n  let code = rewritten.map(part => part.text).join(\",\") + tail.join(\"\")\n  if (code.trimStart().startsWith(\"(\")) code = `;${code}`\n  return { vars, code }\n}\n\nexport const transformSetupScript = (src: string): SetupTransform => {\n  const vars: string[] = []\n  let out = \"\"\n  let i = 0\n  let depth = 0\n  let atStatementStart = true\n\n  while (i < src.length) {\n    const ch = src[i]\n    const next = src[i + 1]\n\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") {\n      const end = skipString(src, i)\n      out += src.slice(i, end)\n      i = end\n      atStatementStart = false\n      continue\n    }\n    if (ch === \"/\" && (next === \"/\" || next === \"*\")) {\n      const end = next === \"/\" ? skipLineComment(src, i) : skipBlockComment(src, i)\n      out += src.slice(i, end)\n      i = end\n      continue\n    }\n    if (ch === \"/\" && regexAllowed(src, i)) {\n      const end = skipRegex(src, i)\n      out += src.slice(i, end)\n      i = end\n      atStatementStart = false\n      continue\n    }\n\n    // `import(...)` is a keyword form, so it can't be intercepted through the\n    // scope - rewrite the identifier to the injected $__import (which loads\n    // .html URLs as components via Component79.fetch and delegates the rest to\n    // native import). The `(` is left for the scanner so depth stays balanced\n    if (ch === \"i\" && (i === 0 || !/[\\w$.]/.test(src[i - 1]))) {\n      IMPORT_CALL_RE.lastIndex = i\n      if (IMPORT_CALL_RE.test(src)) {\n        out += \"$__import\"\n        i += \"import\".length\n        atStatementStart = false\n        continue\n      }\n    }\n\n    if (depth === 0 && atStatementStart) {\n      DECLARATION_START_RE.lastIndex = i\n      const decl = DECLARATION_START_RE.exec(src)\n      if (decl) {\n        const start = i + decl[0].length\n        const end = findStatementEnd(src, start)\n        const { vars: names, code } = rewriteDeclarators(src.slice(start, end))\n        vars.push(...names)\n        out += code\n        i = end\n        atStatementStart = false\n        continue\n      }\n\n      REACTIVE_LABEL_RE.lastIndex = i\n      const label = REACTIVE_LABEL_RE.exec(src)\n      if (label) {\n        REACTIVE_ASSIGN_RE.lastIndex = i\n        const assign = REACTIVE_ASSIGN_RE.exec(src)\n        if (assign) vars.push(assign[1])\n        const start = i + label[0].length\n        const end = findStatementEnd(src, start)\n        // the body is re-scanned rather than sliced raw, so an `import()`\n        // inside it gets the $__import rewrite like anywhere else. Safe to\n        // recurse: strings/comments/regexes copy through unchanged, and a\n        // depth-0 declaration inside a labeled statement is a SyntaxError\n        // in JS anyway, so nothing else can rewrite\n        out += `$__effect(() => { ${transformSetupScript(src.slice(start, end)).code} });`\n        i = end\n        continue\n      }\n    }\n\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch)) depth = Math.max(0, depth - 1)\n\n    if (ch === \"\\n\" || ch === \";\" || ch === \"}\") atStatementStart = true\n    else if (!/\\s/.test(ch)) atStatementStart = false\n\n    out += ch\n    i++\n  }\n\n  return { vars, code: out }\n}\n\n// ---------------------------------------------------------------------------\n// factory scripts - a <script> whose top level has `export default` runs as a\n// plain lexical module instead of a `with`-scoped setup script: no implicit\n// reactivity, no `$:` labels - standard JS that editors and type-checkers\n// understand. The default export is called with the instance context\n// ({ $data, $effect, $emit, $mounted, $self, $$self }) and a returned object\n// is merged into the reactive store for the template to use.\n// Detection is backwards-safe: `export default` is a SyntaxError inside a\n// setup script, so no previously-working component can change behavior.\n// The same scanner rewrites the module-only syntax into a Function body:\n// - `export default X`      -> `$__exports.default = X`\n// - `import d from \"m\"`     -> `const d = $__default(await $__import(\"m\"))`\n//   (and the other static clause forms), so imports resolve through the same\n//   $__import as setup scripts: bundler map first, then fetch/native import\n// ---------------------------------------------------------------------------\n\nconst EXPORT_DEFAULT_RE = /export\\s+default(?![\\w$])/y\n// clause (default/namespace/named, no quotes or parens) + specifier; the\n// no-clause alternative requires the specifier right away, so dynamic\n// `import(...)` and `import.meta` never match\nconst STATIC_IMPORT_RE = /import\\s*(?:([\\w$\\s,{}*]+?)\\s*from\\s*)?([\"'])([^\"'\\n]+)\\2/y\n\n// splits an import clause on top-level commas: `d, { a, b as c }` keeps the\n// braced group together\nconst splitImportClause = (clause: string): string[] => {\n  const parts: string[] = []\n  let depth = 0\n  let start = 0\n  for (let i = 0; i <= clause.length; i++) {\n    const ch = clause[i]\n    if (ch === \"{\") depth++\n    else if (ch === \"}\") depth--\n    else if (i === clause.length || (ch === \",\" && depth === 0)) {\n      const part = clause.slice(start, i).trim()\n      if (part) parts.push(part)\n      start = i + 1\n    }\n  }\n  return parts\n}\n\n// one static import statement -> const bindings from the awaited module\nconst staticImportToAwait = (clause: string | undefined, spec: string, n: number): string => {\n  const source = `await $__import(${JSON.stringify(spec)})`\n  if (clause === undefined) return source // side-effect import\n  const parts = splitImportClause(clause)\n  const bindings: string[] = []\n  let ref = source\n  if (parts.length > 1) {\n    const tmp = `$__mod${n}`\n    bindings.push(`${tmp} = ${source}`)\n    ref = tmp\n  }\n  for (const part of parts) {\n    if (part.startsWith(\"{\")) bindings.push(`${part.replace(/\\s+as\\s+/g, \": \")} = ${ref}`)\n    else if (part.startsWith(\"*\")) bindings.push(`${part.replace(/^\\*\\s*as\\s+/, \"\")} = ${ref}`)\n    else bindings.push(`${part} = $__default(${ref})`)\n  }\n  return `const ${bindings.join(\", \")}`\n}\n\n// ---------------------------------------------------------------------------\n// the component's prop signature\n//\n// A component declares the props it takes as a destructuring pattern, in the\n// place each script mode already puts its inputs: the `:setup` attribute's\n// value, or the factory's *first* parameter (the ctx moved to the second).\n// Position is fixed, so the signature is read straight from the source string -\n// no parser, no execution - and the runtime can seed the defaults on the store\n// before the first render, which is what makes them reach the template even in\n// factory mode (where JS would only apply them inside the function body).\n//\n//   <script :setup=\"{ label = 'Total', step = 1 }\">\n//   export default ({ label = \"Total\" }, { $data }) => {}\n//\n// An object pattern *is* the declaration; anything else (`_`, a plain\n// identifier, no attribute at all) declares nothing and stays permissive.\n// ---------------------------------------------------------------------------\n\n// `as` is the local name the pattern binds the key to, when it isn't the key\n// itself (`{ item: row }`). A prop signature has no use for it - what the\n// store holds is the key - but the slot binder (`:slot=\"{ item: row }\"`) is\n// the same pattern read for the other half: which names the content uses\nexport type PropDecl = { name: string; default?: string; as?: string }\n\nconst IDENTIFIER_RE = /^[A-Za-z_$][\\w$]*$/\n\n// index of the bracket that closes the one opening at src[0], skipping\n// strings, comments and regex literals; src.length when unbalanced\nconst patternCloseIndex = (src: string): number => {\n  let depth = 0\n  let i = 0\n  while (i < src.length) {\n    const ch = src[i]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { i = skipString(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (ch === \"/\" && regexAllowed(src, i)) { i = skipRegex(src, i); continue }\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch) && --depth === 0) return i\n    i++\n  }\n  return src.length\n}\n\n// index of the first `ch` at bracket depth 0, skipping strings and comments\nconst indexOfTopLevel = (src: string, ch: string): number => {\n  let depth = 0\n  let i = 0\n  while (i < src.length) {\n    const c = src[i]\n    if (c === \"'\" || c === '\"' || c === \"`\") { i = skipString(src, i); continue }\n    if (c === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (c === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (c === \"/\" && c !== ch && regexAllowed(src, i)) { i = skipRegex(src, i); continue }\n    if (\"([{\".includes(c)) depth++\n    else if (\")]}\".includes(c)) depth--\n    else if (depth === 0 && c === ch) return i\n    i++\n  }\n  return -1\n}\n\nconst splitTopLevel = (src: string): string[] => {\n  const parts: string[] = []\n  let depth = 0\n  let start = 0\n  let i = 0\n  while (i <= src.length) {\n    const ch = src[i]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { i = skipString(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (ch === \"/\" && regexAllowed(src, i)) { i = skipRegex(src, i); continue }\n    if (ch !== undefined && \"([{\".includes(ch)) depth++\n    else if (ch !== undefined && \")]}\".includes(ch)) depth--\n    else if (i === src.length || (ch === \",\" && depth === 0)) {\n      const part = src.slice(start, i).trim()\n      if (part) parts.push(part)\n      start = i + 1\n    }\n    i++\n  }\n  return parts\n}\n\n// the `=` that opens a default value: the first one at depth 0 that isn't part\n// of `==`/`===` or an arrow's `=>` (so `{ format = a => a }` keeps its default)\nconst defaultAssignIndex = (src: string): number => {\n  let from = 0\n  while (from < src.length) {\n    const at = indexOfTopLevel(src.slice(from), \"=\")\n    if (at === -1) return -1\n    const i = from + at\n    if (src[i + 1] !== \"=\" && src[i + 1] !== \">\" && src[i - 1] !== \"=\" && src[i - 1] !== \"!\") return i\n    from = i + 1\n  }\n  return -1\n}\n\n// a destructuring pattern -> the props it declares. null means \"no signature\":\n// the pattern isn't an object one (`_`, `props`, nothing at all), so the\n// component declares nothing and keeps the permissive, undeclared behavior.\n// `{}` parses to [] - a closed signature that declares zero props\nexport const parsePropsPattern = (pattern: string | undefined): PropDecl[] | null => {\n  const src = (pattern ?? \"\").trim()\n  if (!src.startsWith(\"{\")) return null\n\n  // to the `}` that closes the pattern, so a parameter's own default value\n  // (`({ label } = {})`) is left out of it\n  const close = patternCloseIndex(src)\n  if (close >= src.length) return null // unbalanced: not a pattern we can read\n\n  const props: PropDecl[] = []\n  for (const part of splitTopLevel(src.slice(1, close))) {\n    if (part.startsWith(\"...\")) continue // a rest element names no prop\n    const assign = defaultAssignIndex(part)\n    const named = assign === -1 ? part : part.slice(0, assign)\n    const fallback = assign === -1 ? undefined : part.slice(assign + 1).trim()\n    // `{ user: { id } }` and `{ user: renamed }` both declare `user`: what the\n    // store holds is the key, whatever the pattern binds it to\n    const colon = indexOfTopLevel(named, \":\")\n    const name = (colon === -1 ? named : named.slice(0, colon)).trim()\n    if (!IDENTIFIER_RE.test(name)) continue\n    const decl: PropDecl = { name }\n    if (fallback !== undefined) decl.default = fallback\n    // only a plain rename is kept: `{ user: { id } }` binds no single name, so\n    // there is nothing to record - the prop is still declared under its key\n    const local = colon === -1 ? \"\" : named.slice(colon + 1).trim()\n    if (IDENTIFIER_RE.test(local)) decl.as = local\n    props.push(decl)\n  }\n  return props\n}\n\n// index just past a top-level `export default`, or -1\nconst findExportDefault = (src: string): number => {\n  let i = 0\n  let depth = 0\n  let atStatementStart = true\n  while (i < src.length) {\n    const ch = src[i]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { i = skipString(src, i); atStatementStart = false; continue }\n    if (ch === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (ch === \"/\" && regexAllowed(src, i)) { i = skipRegex(src, i); atStatementStart = false; continue }\n\n    if (ch === \"e\" && depth === 0 && atStatementStart && (i === 0 || !/[\\w$.]/.test(src[i - 1]))) {\n      EXPORT_DEFAULT_RE.lastIndex = i\n      const found = EXPORT_DEFAULT_RE.exec(src)\n      if (found) return i + found[0].length\n    }\n\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch)) depth = Math.max(0, depth - 1)\n    if (ch === \"\\n\" || ch === \";\" || ch === \"}\") atStatementStart = true\n    else if (!/\\s/.test(ch)) atStatementStart = false\n    i++\n  }\n  return -1\n}\n\nconst ASYNC_RE = /^async(?![\\w$])/\nconst FUNCTION_RE = /^function(?![\\w$])\\s*\\*?\\s*[A-Za-z_$][\\w$]*|^function(?![\\w$])\\s*\\*?/\n\n// source text of the exported function's first parameter, or null when there\n// is no parameter list to read (`export default Factory`, `export default\n// props => ...`, an exported object) - all of which declare nothing\nconst firstParameterSource = (src: string): string | null => {\n  const start = findExportDefault(src)\n  if (start === -1) return null\n\n  let i = skipToToken(src, start)\n  const rest = src.slice(i)\n  if (ASYNC_RE.test(rest)) i = skipToToken(src, i + \"async\".length)\n  const fn = FUNCTION_RE.exec(src.slice(i))\n  if (fn) i = skipToToken(src, i + fn[0].length)\n  if (src[i] !== \"(\") return null\n\n  // the parameter list runs to the `)` that closes this `(`\n  let depth = 0\n  let end = i\n  while (end < src.length) {\n    const ch = src[end]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { end = skipString(src, end); continue }\n    if (ch === \"/\" && src[end + 1] === \"/\") { end = skipLineComment(src, end); continue }\n    if (ch === \"/\" && src[end + 1] === \"*\") { end = skipBlockComment(src, end); continue }\n    if (ch === \"/\" && regexAllowed(src, end)) { end = skipRegex(src, end); continue }\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch) && --depth === 0) break\n    end++\n  }\n  return splitTopLevel(src.slice(i + 1, end))[0] ?? \"\"\n}\n\n// the props declared by a factory script's first parameter. Throws the\n// migration error when it finds the pre-0.4 signature there - the ctx used to\n// be the first parameter, and the change is silent otherwise ($data would just\n// come back undefined). `$` is what tells them apart: what carries one comes\n// from the library, what doesn't comes from the parent, everywhere in jq79\nexport const parseFactoryProps = (src: string): PropDecl[] | null => {\n  const first = firstParameterSource(src)\n  if (first === null) return null\n  const props = parsePropsPattern(first)\n  const ctxName = props?.find(prop => prop.name.startsWith(\"$\"))?.name\n  if (ctxName) {\n    throw new Error(\n      `jq79: the factory signature is (props, ctx), so \\`${ctxName}\\` can't be destructured from the first parameter. ` +\n      `Write \\`export default (props, { ${ctxName} }) => …\\`, or \\`_\\` in place of props if the component takes none.`\n    )\n  }\n  return props\n}\n\n// rewrites a factory script into a Function body, or returns null when the\n// script has no top-level `export default` (i.e. it's a regular setup script)\nexport const transformFactoryScript = (src: string): string | null => {\n  let out = \"\"\n  let i = 0\n  let depth = 0\n  let atStatementStart = true\n  let isFactory = false\n  let modCount = 0\n\n  while (i < src.length) {\n    const ch = src[i]\n    const next = src[i + 1]\n    const atWordBoundary = i === 0 || !/[\\w$.]/.test(src[i - 1])\n\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") {\n      const end = skipString(src, i)\n      out += src.slice(i, end)\n      i = end\n      atStatementStart = false\n      continue\n    }\n    if (ch === \"/\" && (next === \"/\" || next === \"*\")) {\n      const end = next === \"/\" ? skipLineComment(src, i) : skipBlockComment(src, i)\n      out += src.slice(i, end)\n      i = end\n      continue\n    }\n    if (ch === \"/\" && regexAllowed(src, i)) {\n      const end = skipRegex(src, i)\n      out += src.slice(i, end)\n      i = end\n      atStatementStart = false\n      continue\n    }\n\n    if (ch === \"i\" && atWordBoundary) {\n      // dynamic import() -> $__import, same rewrite as setup scripts\n      IMPORT_CALL_RE.lastIndex = i\n      if (IMPORT_CALL_RE.test(src)) {\n        out += \"$__import\"\n        i += \"import\".length\n        atStatementStart = false\n        continue\n      }\n      if (depth === 0 && atStatementStart) {\n        STATIC_IMPORT_RE.lastIndex = i\n        const staticImport = STATIC_IMPORT_RE.exec(src)\n        if (staticImport) {\n          out += staticImportToAwait(staticImport[1], staticImport[3], modCount++)\n          i += staticImport[0].length\n          atStatementStart = false\n          continue\n        }\n      }\n    }\n\n    if (ch === \"e\" && atWordBoundary && depth === 0 && atStatementStart) {\n      EXPORT_DEFAULT_RE.lastIndex = i\n      const exportDefault = EXPORT_DEFAULT_RE.exec(src)\n      if (exportDefault) {\n        isFactory = true\n        out += \"$__exports.default =\"\n        i += exportDefault[0].length\n        atStatementStart = false\n        continue\n      }\n    }\n\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch)) depth = Math.max(0, depth - 1)\n\n    if (ch === \"\\n\" || ch === \";\" || ch === \"}\") atStatementStart = true\n    else if (!/\\s/.test(ch)) atStatementStart = false\n\n    out += ch\n    i++\n  }\n\n  return isFactory ? out : null\n}\n\n"],"mappings":"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","names":["jq79_exports","__export","$","$$","$create","$reactive","$toRaw","Component79","PendingComponent79","enableHotReload","hotUpdate","parseComponent","renderComponent","__toCommonJS","$","selectorOrEl","selector","$$","$create","tag","attrs","el","name","value","child","ALLOWED_TAGS","ALLOWED_ATTR","SAFE_URL_PROTOCOLS","isSafeUrl","url","DEFAULT_PORTS","compileHostPattern","pattern","match","host","port","labels","label","allowedHosts","patterns","compiled","p","consultAllowUrl","allowUrl","attr","MAX_SANITIZE_DEPTH","appendSanitizedChildren","source","target","depth","sanitizedChild","sanitizeNode","node","clean","allowedForTag","allowedGlobal","sanitizeHTML","html","options","template","container","getByPath","obj","dotKey","acc","key","isPlainData","value","proto","walkLeaves","path","visit","pathsOverlap","a","b","RAW","$toRaw","raw","STORE","isStore","trackerStack","untracked","fn","ATTACH","ALSO_WAKEN_BY","$reactive","data","exactListeners","anyListeners","effects","proxies","storeApi","notify","isNewKey","listener","effect","dep","isWrappable","bridges","bridge","store","current","unbridge","wrap","cached","tombstones","proxy","target","receiver","stored","notified","had","deleted","reactive","$on","immediate","$onAny","$effect","run","alsoWakenBy","running","dirty","cycles","deps","attachAndRun","detach","drop","$__attach","$dispose","unsubscribe","createEffectScope","scope","disposers","runs","dispose","DECLARATION_START_RE","REACTIVE_LABEL_RE","IMPORT_CALL_RE","REACTIVE_ASSIGN_RE","skipString","src","start","quote","i","skipLineComment","end","skipBlockComment","skipToToken","REGEX_AFTER_WORD","regexAllowed","at","ch","open","skipRegex","inClass","CONTINUATION_RE","lastMeaningfulBefore","findStatementEnd","depth","next","splitDeclarators","parts","lastEnd","flush","patternBindings","pattern","IDENTIFIER_RE","names","part","splitTopLevel","patternCloseIndex","assign","defaultAssignIndex","colon","indexOfTopLevel","rewriteDeclarators","vars","rewritten","raw","codeEnd","lead","body","tail","target","isPattern","code","transformSetupScript","out","atStatementStart","decl","label","EXPORT_DEFAULT_RE","STATIC_IMPORT_RE","splitImportClause","clause","staticImportToAwait","spec","source","bindings","ref","tmp","c","from","parsePropsPattern","close","props","named","fallback","name","local","findExportDefault","found","ASYNC_RE","FUNCTION_RE","firstParameterSource","rest","fn","parseFactoryProps","first","ctxName","prop","transformFactoryScript","isFactory","modCount","atWordBoundary","staticImport","exportDefault","VERSION","elementAttrs","el","attr","elementToAST","attrs","component","COMPONENT_TAG_ATTR","node","text","compiled","compileExpr","expr","params","key","fn","MISSING_NAME_RE","MAX_PENDING_REPORTS","pendingReports","reportedExprErrors","pendingScripts","flushScheduled","reportedFailedExprs","flushExprReports","name","scope","scheduleExprReportFlush","trackScript","settled","release","reportFailedExpr","error","message","reportExprError","match","runExpr","extras","evalExpr","evalHandler","interpolate","template","_","CONTROL_ATTRS","isControlAttr","EACH_PATTERN","bindEvent","modifiers","mods","event","handler","wireTagEvent","instance","listener","untracked","kebabToCamel","c","camelToKebab","boundsOf","removeRange","first","last","next","moveRangeAfter","prev","ref","findComponentKey","tag","normalized","obj","componentsInScope","names","unresolvedComponent","MAX_NESTING_DEPTH","nestingDepth","SLOTS","isSlotTag","slotName","suffix","slotAttrOf","slotAttrName","isMeaningful","partitionSlots","contents","loose","child","hasLoose","bindSlotProps","binder","props","parsePropsPattern","as","fallback","local","value","misplacedSlotContent","buildSlots","slots","content","makeSlotRenderer","parentScope","slotScope","fx","shadow","inherited","ALSO_WAKEN_BY","contentFx","createEffectScope","renderNodes","renderSlot","wrapper","anchor","endAnchor","render","SCOPE_ATTR","renderNestedComponent","models","events","sources","hasSpread","modelAttr","modelProp","assignment","unassignable","prop","resolveProps","out","current","currentDef","childFx","reported","reportUnresolved","UNFILLED_PROPS","nextDef","Component79","warned","rawName","declared","declaredPropSet","warnUndeclared","seed","pickDeclared","holder","syncFx","written","nextKeys","createWithScope","source","target","classNames","on","normalizeAllowUrl","policy","url","allowedHosts","BOOLEAN_ATTRS","applyAttr","boolean","renderNode","outerScope","withExpr","componentKey","PENDING_SCRIPTS","mayUpgrade","upgraded","replacement","range","bindExpr","boundKeys","bound","classExpr","classToggles","staticClasses","textExpr","htmlExpr","allowedExpr","options","sanitizeHTML","valueExpr","renderConditional","branches","activeBranch","branchFx","branch","rendered","defineScopeVar","isPlainObject","proto","renderEach","itemName","atName","listExpr","keyExpr","_each","_key","itemAttrs","itemNode","entries","warnedDuplicates","list","pairs","item","index","previous","entry","bucket","seen","moved","nextEntries","at","itemScope","existing","itemFx","prevNode","nodes","fragment","i","textNode","nextBranch","candidate","elseif","elseNode","renderComponent","data","VOID_ELEMENTS","SELF_CLOSING_RE","RAW_BLOCK_RE","expandSelfClosingTags","src","chunk","OPEN_TAG_RE","ATTR_SPREAD_RE","expandPropsSpread","_match","n","rewritten","whole","space","ATTR_NAME_RE","CLOSE_SLOT_RE","SLOT_TAG_RE","kebabTagName","COMPONENT_TAG_RE","TRAILING_SLASH_RE","stampComponentTag","stamp","slash","expandNameCase","scopeHash","hash","stampScope","scopeSelector","selectorText","part","selector","pseudoAt","pseudoElement","scopeRules","rules","rule","scopeCss","css","sheet","COMPONENT_NAME_RE","parseComponentString","prepared","root","own","declarations","parts","componentPartsFrom","siblings","elements","hashSource","scripts","styles","block","style","isScoped","importResource","fetchComponent","RESOLVABLE_SPECIFIER_RE","resolveSpecifier","spec","filename","sourceUrlComment","headStyle","styleRegistry","acquireStyle","releaseStyle","runSetupScript","code","effect","instanceHelpers","importer","helpers","SETUP_HELPERS","scriptScope","state","result","declareProps","store","setupSignature","script","pattern","warnUnreadableSignature","signatureWarned","declaredPropNames","parseFactoryProps","into","undeclaredWarned","said","siblingsInScope","inScope","any","interopDefault","mod","runFactoryScript","$__exports","logError","invoked","merging","invoke","factory","merge","bindings","returned","HOT_FLAG","HOT_RUNTIME","hotRegistry","hotRegister","refs","hotKey","hotUpdate","orphaned","partsFor","rerendered","enableHotReload","STUCK_RENDER_DELAY","warnIfStuck","gates","timer","response","__publicField","sibling","marker","live","parent","before","PendingComponent79","urls","eventName","siblingScope","raw","unfilled","$reactive","warnedModelUpdate","$emit","payload","resolveMounted","mounted","resolve","endMarker","$$self","found","$self","modules","$import","injected","args","defer","allSync","resolveGate","open","deferred","factoryCode","transformFactoryScript","run","body","vars","transformSetupScript","pending","settle","templateScope","receiver","$","nextNode","action","onfulfilled","onrejected","onfinally","parseComponent","component","Component79","SETUP_HELPERS","$","$$","$create","$reactive","$toRaw","HOT_FLAG","enableHotReload"]}
+{"version":3,"sources":["../src/jq79.ts","../src/dom.ts","../src/reactive.ts","../src/transform.ts"],"sourcesContent":["\nimport { $, $$, $create, sanitizeHTML, allowedHosts } from \"./dom\"\nimport type { AllowUrl } from \"./dom\"\nimport { $reactive, $toRaw, untracked, createEffectScope, ALSO_WAKEN_BY } from \"./reactive\"\nimport type { ReactiveDeepData, EffectScope } from \"./reactive\"\nimport { transformSetupScript, transformFactoryScript, parsePropsPattern, parseFactoryProps, type PropDecl } from \"./transform\"\n\nexport { $, $$, $create } from \"./dom\"\nexport { $reactive, $toRaw } from \"./reactive\"\n\n// the package version, substituted at build time (tsup/vitest `define`, read\n// from package.json - releases bump it there and nowhere else). The typeof\n// guard is what keeps the raw source runnable: tests and any bundler that\n// doesn't define it see a bare identifier, not a ReferenceError\ndeclare const __JQ79_VERSION__: string\nconst VERSION = typeof __JQ79_VERSION__ === \"string\" ? __JQ79_VERSION__ : \"0.0.0-dev\"\n\ntype TemplateNode = {\n  tag: string\n  attrs: Record<string, string>\n  children: (TemplateNode | string)[]\n  // the tag as the author capitalized it, present only when they wrote it\n  // uppercase-initial - i.e. when they meant a component. `tag` cannot answer\n  // this: the HTML parser lowercases it, so the claim is captured before the\n  // parse (see stampComponentTag) and lifted off attrs here, where it stops\n  // looking like an attribute to every loop downstream\n  component?: string\n}\n\ntype TagBlock = {\n  attrs: Record<string, string>\n  content: string\n  // <style scoped> only: `content` rewritten to require the component's scope\n  // attribute. Kept beside the original rather than replacing it, because a\n  // shadow root doesn't want it - see headStyle()\n  scoped?: string\n}\n\nconst elementAttrs = (el: Element): Record<string, string> =>\n  Object.fromEntries(Array.from(el.attributes).map(attr => [attr.name, attr.value]))\n\n// text is kept verbatim - not trimmed, not dropped when it's only whitespace.\n// A template is HTML, so the space in `<span>a</span>\\n<span>b</span>` is the\n// same space the browser would collapse-and-render between them, and CSS gets\n// to decide what it's worth (nothing in a block or flex container, one space\n// between inline elements). Trimming it here, as this used to, silently glued\n// siblings together and ate the spaces in `hola <b>mundo</b> adios`\n//\n// A <template>'s children are read from its .content fragment: that is where\n// the HTML parser puts them, and its childNodes are empty. Without the descent\n// they are not in the AST at all - which is where slot content is written\n// (<template :slot.name>), and why a nested <template> used to render as an\n// empty element whatever was inside it\nconst elementToAST = (el: Element): TemplateNode => {\n  const attrs = elementAttrs(el)\n  // the pre-parse stamp becomes a field and leaves attrs entirely: it is not a\n  // prop, not a directive and not an attribute, and every loop that walks attrs\n  // would otherwise need to know its name\n  const component = attrs[COMPONENT_TAG_ATTR]\n  delete attrs[COMPONENT_TAG_ATTR]\n  return {\n    tag: el.tagName.toLowerCase(),\n    attrs,\n    ...(component === undefined ? {} : { component }),\n    children: Array.from((el instanceof HTMLTemplateElement ? el.content : el).childNodes).flatMap((node): (TemplateNode | string)[] => {\n      if (node.nodeType === Node.TEXT_NODE) {\n        const text = node.textContent ?? \"\"\n        return text ? [text] : []\n      }\n      if (node.nodeType === Node.ELEMENT_NODE) {\n        return [elementToAST(node as Element)]\n      }\n      return []\n    })\n  }\n}\n\n// evaluated with `with` (rather than passing scope keys as positional params)\n// so only the identifiers an expression actually references are read from\n// `scope` - which is what makes dependency tracking in $reactive\n// precise instead of \"read everything up front\". `extras` are passed as\n// function parameters (outside the `with`), so scope keys still win but names\n// like $event resolve when the scope doesn't shadow them\n//\n// Compiled functions are cached: an expression is re-evaluated on every effect\n// run - once per interpolation, once per :each item - while the set of distinct\n// expressions is fixed by the source. The `extras` names are part of the key,\n// not just the expression: they become the function's parameters, so the same\n// expression compiled with and without $event is two different functions. A\n// syntactically invalid expression caches its failure (null) so it isn't\n// recompiled, and rethrown as undefined, exactly as before\nconst compiled = new Map<string, Function | null>()\n\nconst compileExpr = (expr: string, params: string[]): Function | null => {\n  const key = `${params.join(\",\")}|${expr}`\n  let fn = compiled.get(key)\n  if (fn === undefined) {\n    try {\n      // the newline before `)` ends a trailing line comment in the\n      // expression ({{ msg // greeting }}); ASI doesn't apply inside parens,\n      // so everything else is untouched. Without it the comment eats the\n      // rest of this single-line body and the expression never compiles\n      fn = new Function(\"$scope\", ...params, `with ($scope) { return (${expr}\\n); }`)\n    } catch {\n      fn = null // a syntax error: it will never compile, so don't try again\n    }\n    compiled.set(key, fn)\n  }\n  return fn\n}\n\n// a template expression is re-evaluated constantly - once per effect run, once\n// per interpolation, once per :each item - so a value that is briefly undefined\n// mid-render has to fail quietly, and the catch below stays. A ReferenceError\n// is the one failure worth a word: `with` resolves a name against the store and\n// then globalThis, so a name that resolves nowhere is declared nowhere - a\n// typo, a dropped prop, or the trap this was written for, a top-level\n// `function` declaration, which transformSetupScript leaves as an ordinary\n// lexical binding instead of a store property\n//\n// It is reported late rather than where it throws, because \"declared nowhere\"\n// is not yet decidable at that moment: a factory script assigns its bindings to\n// the store when it returns, so an async factory renders its whole template\n// before any of its names exist. Reporting waits until no script is still\n// running (pendingScripts), and then asks whether the name resolves *now*.\n//\n// The re-check is `name in scope` rather than a re-evaluation, because\n// re-evaluating is not pure: `@click=\"count++ + missing\"` increments before it\n// throws, and running it again to see if it still throws would increment twice\n// and notify. `in` walks the same scope chain (:each scopes are\n// Object.create(scope), :with is a proxy over it) and evaluates nothing\nconst MISSING_NAME_RE = /^(?:([\\w$]+) is not defined|Can't find variable: ([\\w$]+))/\n\n// the queue holds live scopes, so it is capped: a script that never settles\n// would otherwise let it grow for the life of the page\nconst MAX_PENDING_REPORTS = 100\n\ntype PendingReport = { name: string; expr: string; scope: Record<string, any> }\n\nconst pendingReports = new Map<string, PendingReport>()\nconst reportedExprErrors = new Set<string>()\nlet pendingScripts = 0\nlet flushScheduled = false\n\n// everything else an expression can throw - overwhelmingly a member access on\n// an undefined value, `{{ game.is.loaded }}` over a game with no `is`. Unlike a\n// missing name it needs no deferral and gets none: the engine already caught a\n// real exception and wrote the message, so there is nothing left to decide and\n// it is reported where it throws, as an error rather than a warning.\n//\n// That means a value still on its way is reported too - `{{ user.name }}` over\n// a user that a fetch will fill renders empty and says so, once. It is a\n// deliberate trade against the silence it replaces, which hid a render that was\n// actively wrong (a thrown `:disabled` is falsy, so the button rendered\n// *enabled*). The fix is the one the message names: `user?.name`, or `:if`.\n//\n// Deduped by expression text alone. A `:each` over 1000 rows throws 1000 times\n// per render and the Set is what keeps that to one line; keying finer - by\n// message too, as the missing-name queue does - would let one broken path\n// report once per distinct message. There is no queue behind it because there\n// is nothing to re-check, and so nothing that could retain a live scope\nconst reportedFailedExprs = new Set<string>()\n\nconst flushExprReports = () => {\n  flushScheduled = false\n  if (pendingScripts > 0) return // a script started meanwhile; its release re-schedules\n  pendingReports.forEach(({ name, expr, scope }, key) => {\n    if (name in scope) return // it arrived late - a factory's bindings, a prop\n    reportedExprErrors.add(key)\n    console.warn(\n      `jq79: ${name} is not defined - evaluating \"${expr}\". Template expressions ` +\n      `resolve against the component store: a top-level let/var/const in a :setup ` +\n      `script, a declared prop, or a global. Note a \"function name() {}\" declaration ` +\n      `is not on the store - write \"const name = () => {}\".`\n    )\n  })\n  pendingReports.clear()\n}\n\nconst scheduleExprReportFlush = () => {\n  if (flushScheduled || pendingScripts > 0 || !pendingReports.size) return\n  flushScheduled = true\n  queueMicrotask(flushExprReports)\n}\n\n// scripts run before the template renders, so the counter is already up when\n// the first evaluation fails. Both script modes settle through a promise;\n// the factory's has to cover the merge, not just the module body\nconst trackScript = (settled: Promise<unknown>) => {\n  pendingScripts++\n  const release = () => {\n    pendingScripts--\n    scheduleExprReportFlush()\n  }\n  settled.then(release, release)\n}\n\n// console.error, not warn: a name that resolves nowhere is a warning because\n// the runtime can only say the name is absent, while this one caught a real\n// exception - it has a message the engine wrote, and the expression rendered as\n// nothing instead of doing what it says\nconst reportFailedExpr = (expr: string, error: unknown) => {\n  if (reportedFailedExprs.has(expr)) return\n  reportedFailedExprs.add(expr)\n  const message = (error as Error)?.message || String(error)\n  console.error(\n    `jq79: ${message} - evaluating \"${expr}\". The expression rendered as nothing. ` +\n    `If the value arrives later, guard it - \"a?.b\", or :if on the element.`\n  )\n}\n\nconst reportExprError = (expr: string, scope: Record<string, any>, error: unknown) => {\n  if (!(error instanceof ReferenceError)) return reportFailedExpr(expr, error)\n  const match = MISSING_NAME_RE.exec(error.message)\n  const name = match?.[1] ?? match?.[2]\n  if (!name) return // an engine whose wording we don't know: stay quiet, as before\n  // keyed on name and expression, not on the expression alone, so two missing\n  // names in one expression stay distinguishable - and so a :each of 1000 items\n  // enqueues one entry rather than 1000\n  const key = `${name}|${expr}`\n  if (reportedExprErrors.has(key) || pendingReports.has(key)) return\n  if (pendingReports.size >= MAX_PENDING_REPORTS) return\n  pendingReports.set(key, { name, expr, scope })\n  scheduleExprReportFlush()\n}\n\nconst runExpr = (expr: string, scope: Record<string, any>, extras?: Record<string, any>): any => {\n  const fn = compileExpr(expr, extras ? Object.keys(extras) : [])\n  if (!fn) return undefined // a syntax error: compileExpr cached the failure, and it stays undefined\n  return fn(scope, ...(extras ? Object.values(extras) : []))\n}\n\nconst evalExpr = (expr: string, scope: Record<string, any>, extras?: Record<string, any>): any => {\n  try {\n    return runExpr(expr, scope, extras)\n  } catch (error) {\n    reportExprError(expr, scope, error)\n    return undefined\n  }\n}\n\n// the same evaluation for an @event attribute, which swallows far less. Every\n// word of the reason evalExpr catches is about rendering: an expression is\n// re-evaluated per effect run, per interpolation, per :each item, so a value\n// that is briefly undefined mid-render has to render empty rather than tear the\n// render down. A handler runs in an event listener - not in an effect, once,\n// when the user clicked - so there is no transient failure to absorb, only a\n// bug to report, and an exception belongs in the console with its stack. That\n// is what `@click=\"save\"` has always done (the call happens outside the try,\n// on the returned function); this is what makes `@click=\"save()\"` and\n// `@click=\"count++\"` behave the same rather than the other way round.\n//\n// ReferenceError is the exception, for the reason it always is: it is not yet\n// decidable at throw time. A factory assigns its names to the store when it\n// returns, so a click while one is still in flight throws for a name that is\n// about to exist - reportExprError re-checks after the scripts settle and stays\n// quiet if it arrived, which throwing here would replace with a false alarm\nconst evalHandler = (expr: string, scope: Record<string, any>, extras: Record<string, any>): any => {\n  try {\n    return runExpr(expr, scope, extras)\n  } catch (error) {\n    if (!(error instanceof ReferenceError)) throw error\n    reportExprError(expr, scope, error)\n    return undefined\n  }\n}\n\n// [\\s\\S] rather than `.` so an expression can span lines, like the ones in\n// directive attributes (which reach evalExpr wrapped in parens either way)\nconst interpolate = (template: string, scope: Record<string, any>): string =>\n  template.replace(/{{\\s*([\\s\\S]+?)\\s*}}/g, (_, expr) => evalExpr(expr, scope) ?? \"\")\n\n\nconst CONTROL_ATTRS = new Set([\":attrs\", \":class\", \":value\", \":checked\", \":selected\", \":if\", \":elseif\", \":else\", \":each\", \":key\", \":with\", \":text\", \":html\", \":html.allowed\", \":props\"])\n\n// a control attribute is one the static-attr loop and nested-component prop\n// collection must skip. The set holds the fixed names; `:class.<name>` (the\n// single-flag shorthand) and `:props.<n>` (one spread among several) are\n// open-ended, so they're matched by prefix - they can't be enumerated into the set\nconst isControlAttr = (attr: string): boolean =>\n  CONTROL_ATTRS.has(attr) || attr.startsWith(\":class.\") || attr.startsWith(\":props.\") ||\n  attr === \":slot\" || attr.startsWith(\":slot.\")\n// `item in items`, `item, i in items`, `(value, key) in props` - the second\n// binding is the array index or the object key, parens optional (Vue-style).\n// The list expression can span lines, so it matches [\\s\\S] rather than `.`\nconst EACH_PATTERN = /^\\s*\\(?\\s*(\\w+)\\s*(?:,\\s*(\\w+))?\\s*\\)?\\s+in\\s+([\\s\\S]+)$/\n\ntype ConditionalBranch = { expr?: string; node: TemplateNode }\n\n\n// @event attributes: @click=\"onClick\", @submit.prevent=\"$event => onSubmit($event)\",\n// or an inline statement like @click=\"count = count + 1\". The expression is\n// evaluated (with `$event` in scope) on every event; if it yields a function,\n// that function is then invoked with the event - so both a handler reference\n// and an inline arrow/statement work. Modifiers after dots: .prevent .stop\n// .self (runtime guards) and .once .capture (addEventListener options)\nconst bindEvent = (el: Element, attr: string, expr: string, scope: Record<string, any>) => {\n  const [name, ...modifiers] = attr.slice(1).split(\".\")\n  const mods = new Set(modifiers)\n\n  el.addEventListener(name, event => {\n    if (mods.has(\"self\") && event.target !== el) return\n    if (mods.has(\"prevent\")) event.preventDefault()\n    if (mods.has(\"stop\")) event.stopPropagation()\n\n    const handler = evalHandler(expr, scope, { $event: event })\n    if (typeof handler === \"function\") handler.call(el, event)\n  }, { once: mods.has(\"once\"), capture: mods.has(\"capture\") })\n}\n\n// @event on a component tag: the tag renders as comment anchors, so there is\n// no element to listen on - the attribute subscribes to the child instance's\n// $emit channel (instance.on) instead, which survives the child's re-renders\n// and works detached. Native DOM events from the child's inner DOM never\n// arrive here: they bubble past the anchors to shared ancestors (a listener\n// on a wrapping element hears those); a child that wants its native event\n// heard on its tag re-emits it. .prevent flips the child's $emit() return to\n// false, .stop keeps the emit off the DOM dispatch, .once unsubscribes after\n// one call; .self and .capture have no meaning on this channel and are ignored\nconst wireTagEvent = (instance: Component79, attr: string, expr: string, scope: Record<string, any>) => {\n  const [name, ...modifiers] = attr.slice(1).split(\".\")\n  const mods = new Set(modifiers)\n\n  const listener = (event: CustomEvent) => {\n    if (mods.has(\"prevent\")) event.preventDefault()\n    if (mods.has(\"stop\")) event.stopPropagation()\n    if (mods.has(\"once\")) instance.off(name, listener)\n\n    // untracked, so a tag handler behaves like an element handler no matter\n    // when the emit fires: an element handler never runs inside an effect,\n    // but $emit can (a $: that emits, a setup-script emit inside the parent's\n    // creation effect), and the handler's reads would land in that effect's\n    // deps. Today that is contained - cross-store deps are never notified,\n    // and the creation effect's definition guard no-ops a spurious wake - but\n    // \"what a handler reads is nobody's dependency\" shouldn't hinge on either\n    untracked(() => {\n      const handler = evalHandler(expr, scope, { $event: event })\n      if (typeof handler === \"function\") handler(event)\n    })\n  }\n  instance.on(name, listener)\n}\n\nconst kebabToCamel = (name: string) => name.replace(/-(\\w)/g, (_, c: string) => c.toUpperCase())\n\n// the inverse, used only by the pre-parse name rewrite (see expandNameCase):\n// uppercase ASCII letters only, never digits - `:props.0` is a generated\n// attribute name and splitting on digits would mangle it. Round-trips through\n// kebabToCamel, acronyms included: userID -> user-i-d -> userID\nconst camelToKebab = (name: string) => name.replace(/[A-Z]/g, c => `-${c.toLowerCase()}`)\n\n// the stable boundaries of a rendered chunk. An element is its own handle, but\n// a fragment (a nested component: two anchors with the instance's DOM between\n// them) empties itself into the parent on insertion - after that its identity\n// answers nothing, and what stays put are its first and last children. Callers\n// that reposition or remove a chunk later (:each entries, :if branches) must\n// capture its bounds *before* inserting it and work on the range\ntype NodeRange = { first: Node; last: Node }\n\nconst boundsOf = (node: Node): NodeRange =>\n  node instanceof DocumentFragment\n    ? { first: node.firstChild!, last: node.lastChild! }\n    : { first: node, last: node }\n\n// removes [first..last] inclusive - the range's content is dynamic (a nested\n// component's DOM comes and goes between its anchors), so it walks siblings\n// rather than assuming any particular nodes in between\nconst removeRange = ({ first, last }: NodeRange) => {\n  for (let node: Node | null = first; node; ) {\n    const next: Node | null = node === last ? null : node.nextSibling\n    node.parentNode?.removeChild(node)\n    node = next\n  }\n}\n\n// removes several ranges that sit next to each other, in one DOM call each run\n// rather than one per node. A list dropping all its rows hands them over as a\n// single span: unlinking 10,000 rows one at a time is 40% of that operation,\n// profiled - see TODOS/2026-08-23.batch-range-removal.md. Runs are built by the\n// caller, which is the only place that knows what else is going\nconst removeRuns = (runs: NodeRange[][]) => {\n  runs.forEach(run => {\n    if (run.length === 1) return removeRange(run[0])\n    const parent = run[0].first.parentNode\n    if (!parent) return\n    // both ends sit between nodes, so nothing is partially selected and whole\n    // nodes are what gets unlinked\n    const range = document.createRange()\n    range.setStartBefore(run[0].first)\n    range.setEndAfter(run[run.length - 1].last)\n    range.deleteContents()\n  })\n}\n\n// groups the entries `isDead` selects into runs of DOM neighbours, walking\n// `ordered` (which is in DOM order). Adjacency is confirmed rather than assumed:\n// a gap - an entry removed earlier in the same pass - starts a new run, so a\n// live entry can never end up inside one\nconst contiguousRuns = <T extends { range: NodeRange }>(ordered: T[], isDead: (entry: T) => boolean): NodeRange[][] => {\n  const runs: NodeRange[][] = []\n  let run: NodeRange[] | null = null\n  ordered.forEach(entry => {\n    if (!isDead(entry)) {\n      run = null\n      return\n    }\n    if (run && run[run.length - 1].last.nextSibling === entry.range.first) run.push(entry.range)\n    else runs.push((run = [entry.range]))\n  })\n  return runs\n}\n\n// moves [first..last] inclusive so the range starts right after `prev`\nconst moveRangeAfter = ({ first, last }: NodeRange, prev: Node) => {\n  const ref = prev.nextSibling\n  for (let node: Node | null = first; node; ) {\n    const next: Node | null = node === last ? null : node.nextSibling\n    prev.parentNode!.insertBefore(node, ref)\n    node = next\n  }\n}\n\n// finds the scope variable a template tag refers to. HTML parsing lowercases\n// tag names, so <NestedComponent> arrives as \"nestedcomponent\" and matching is\n// case-insensitive with dashes stripped (<nested-component> works too). Only\n// PascalCase scope keys participate, so ordinary variables named like real\n// elements (title, code, ...) never hijack them\nconst scanComponentKey = (scope: Record<string, any>, tag: string): string | null => {\n  const normalized = tag.replace(/-/g, \"\").toLowerCase()\n  for (let obj: any = scope; obj && obj !== Object.prototype; obj = Object.getPrototypeOf(obj)) {\n    for (const key of Object.keys(obj)) {\n      if (/^[A-Z]/.test(key) && key.replace(/-/g, \"\").toLowerCase() === normalized) return key\n    }\n  }\n  return null\n}\n\n// The scan above is run for every element rendered, and it walks the whole\n// scope chain calling Object.keys at each level - which profiling puts at 13.7%\n// of the create path, four times the next attributable frame, almost all of it\n// answering \"no\" for tags like <td>. Within one render pass the answer can't\n// change: it is a *key*, not the value behind it, so every row of a :each\n// resolves a tag identically, and a store write mid-pass restarts the pass\n// rather than continuing it (the reentrancy guard in reactive.ts).\n//\n// So it is memoized for exactly one pass and no longer. It has to be no longer:\n// a template renders before its setup script settles, so `const Row = await\n// $import(...)` arrives as a new store key *after* elements are on the page -\n// and a cached \"no component called Row\" that outlived the pass would never be\n// revisited. See TODOS/2026-08-23.component-key-scan.md\n// The memo answers for one *base* scope - the one the pass was opened with -\n// and nothing below it. A lookup walks from wherever it starts up to that base,\n// checking own keys as it goes (an :each item scope has two or three, a :with\n// a handful), and only then consults the memo. So a name introduced under the\n// base still shadows correctly, and a scope that never reaches the base at all\n// - a nested component renders against its own store - has simply been fully\n// scanned by the time the walk ends, which is the answer anyway\nlet tagMemo: Map<string, string | null> | null = null\nlet memoBase: object | null = null\n\n// opened and closed by hand rather than by a wrapper taking a callback: a\n// component that renders itself through :each stacks one renderEach per level,\n// and a callback would add a frame to each of them. The cyclic-component test\n// cuts off at 200 levels, and on a CI runner that extra frame per level was the\n// difference between cutting off and a RangeError - the same reason $effect\n// keeps its own shape (see reactive.ts)\ntype RenderPass = { memo: Map<string, string | null> | null; base: object | null }\n\nconst openRenderPass = (base: Record<string, any>): RenderPass => {\n  const outer: RenderPass = { memo: tagMemo, base: memoBase }\n  tagMemo = new Map()\n  memoBase = base\n  return outer\n}\n\nconst closeRenderPass = (outer: RenderPass) => {\n  tagMemo = outer.memo\n  memoBase = outer.base\n}\n\nconst findComponentKey = (scope: Record<string, any>, tag: string): string | null => {\n  if (!tagMemo) return scanComponentKey(scope, tag)\n  const normalized = tag.replace(/-/g, \"\").toLowerCase()\n  for (let obj: any = scope; obj && obj !== Object.prototype; obj = Object.getPrototypeOf(obj)) {\n    if (obj === memoBase) {\n      if (tagMemo.has(tag)) return tagMemo.get(tag)!\n      const key = scanComponentKey(obj, tag)\n      tagMemo.set(tag, key)\n      return key\n    }\n    for (const key of Object.keys(obj)) {\n      if (/^[A-Z]/.test(key) && key.replace(/-/g, \"\").toLowerCase() === normalized) return key\n    }\n  }\n  return null\n}\n\n// every name a tag *could* have resolved to, walking the same chain\n// findComponentKey does. Deduped and sorted, because the chain can hold one\n// name twice (a prop shadowing a sibling) and the order it comes out in is the\n// prototype's, which means nothing to a reader scanning for their typo\nconst componentsInScope = (scope: Record<string, any>): string[] => {\n  const names = new Set<string>()\n  for (let obj: any = scope; obj && obj !== Object.prototype; obj = Object.getPrototypeOf(obj)) {\n    for (const key of Object.keys(obj)) if (/^[A-Z]/.test(key)) names.add(key)\n  }\n  return [...names].sort()\n}\n\n// a tag whose name resolves to no component, once nothing can still supply one.\n// The error names what *is* in scope: the mistake is nearly always a typo or a\n// missing import, and both are one glance from the list. \"(none)\" is its own\n// answer - it says the component has no components at all, which points at the\n// import rather than at the spelling\nconst unresolvedComponent = (tag: string, scope: Record<string, any>): Error => {\n  const names = componentsInScope(scope)\n  return new Error(\n    `jq79: <${tag}> is not defined - no component of that name is in scope, and nothing renders here. ` +\n    `Import it in a :setup script, declare it as a prop, or add a <template name=\"${tag}\"> to this file. ` +\n    `In scope: ${names.length ? names.join(\", \") : \"(none)\"}.`\n  )\n}\n\n// how deep a component may nest inside itself before the runtime calls it a\n// cycle. Deeper than any real tree, shallower than the JS stack: a truncated\n// render with an error on the console beats a stack overflow with none\nconst MAX_NESTING_DEPTH = 200\nlet nestingDepth = 0\n\n// ---------------------------------------------------------------------------\n// slots - content projection\n//\n// A component tag's children are content the child renders where it wrote a\n// <slot>. The dot marks the named variant on both sides, like :model.<name>\n// and :class.<name> already do:\n//\n//   <!-- Card.html -->        <!-- the parent -->\n//   <section>                 <Card>\n//     <header>                  <template :slot.header><h2>{{ t }}</h2></template>\n//       <slot.header>?</slot.header>\n//     </header>                 <p>{{ body }}</p>\n//   <slot />                  </Card>\n//   </section>\n//\n// Three rules decide everything below:\n//\n// 1. Content belongs to the parent - its AST, its scope, its effects, its\n//    scoped styles. The child decides *where* it goes and *whether* it goes,\n//    never what the names in it mean.\n// 2. Slot props are declared, not injected: `:slot=\"{ item }\"` on the usage\n//    site, for the same reason :each writes `item in rows`. Every bare name in\n//    the parent's file is introduced by the parent, so a `<slot :item>` the\n//    child adds later can't silently capture one.\n// 3. What isn't projected isn't rendered. No <slot>, or one behind a false\n//    :if, and the content's effects never exist.\n//\n// The content travels as a thunk, not as DOM: an instance is replaced (a\n// definition swap, a hot reload) and one <slot> may render many times, so a\n// pre-rendered fragment would leak effects and could only be inserted once\n// ---------------------------------------------------------------------------\n\n// renders one slot's content at the position the child put the <slot>: it is\n// handed the slot's props (lazy, so each read re-evaluates in the child's\n// scope), that position's scope and effect scope, and the style mode the\n// child renders under\ntype SlotRenderer = (\n  props: Record<string, () => any>,\n  slotScope: Record<string, any>,\n  fx: EffectScope,\n  shadow: boolean\n) => Node\n\ntype SlotMap = Record<string, SlotRenderer>\n\n// the content an instance was handed, by slot name. Symbol-keyed and\n// non-enumerable on the store's data, like UNFILLED_PROPS: it rides the scope\n// chain (so a <slot> inside an :each or a :with finds it) and never shows up\n// as data - not in Object.keys, not in a snapshot spread, not in the props a\n// nested component is handed\nconst SLOTS = Symbol(\"jq79.slots\")\n\n// <slot>, <slot.header-bar>: the hole and its name. Names arrive kebab-case\n// whichever way they were authored (the HTML parser lowercases tag names and\n// attribute modifiers alike, so expandNameCase normalizes camelCase to kebab\n// before parsing) and are camelCase where read - <slot.header-bar> and\n// <slot.headerBar> are :slot.header-bar is $slots.headerBar\nconst isSlotTag = (tag: string): boolean => tag === \"slot\" || tag.startsWith(\"slot.\")\n\nconst slotName = (suffix: string): string => (suffix ? kebabToCamel(suffix) : \"default\")\n\n// the content of one slot, as written at the usage site\ntype SlotContent = { nodes: (TemplateNode | string)[]; binder?: string }\n\n// the :slot attribute of a <template>, if it carries one\nconst slotAttrOf = (node: TemplateNode): string | undefined =>\n  Object.keys(node.attrs).find(attr => attr === \":slot\" || attr.startsWith(\":slot.\"))\n\nconst slotAttrName = (name: string) => (name === \"default\" ? \":slot\" : `:slot.${name}`)\n\n// whitespace-only text between two <template :slot> blocks is the indentation\n// between them and nothing else - the same call renderNodes makes between the\n// branches of an :if chain. It is what decides whether a tag has default\n// content at all, which is what $slots.default answers\nconst isMeaningful = (node: TemplateNode | string): boolean => typeof node !== \"string\" || node.trim() !== \"\"\n\n// a component tag's children, partitioned by slot name: a direct\n// <template :slot.<name>> child fills that name, everything else is the\n// default slot's content. The attribute's value is the pattern the content\n// binds the slot's props to - on the tag itself for the default, since the\n// default content has no <template> of its own to carry it\nconst partitionSlots = (node: TemplateNode): Record<string, SlotContent> => {\n  const contents: Record<string, SlotContent> = {}\n  const loose: (TemplateNode | string)[] = []\n\n  node.children.forEach(child => {\n    const attr = typeof child === \"object\" && child.tag === \"template\" ? slotAttrOf(child) : undefined\n    if (typeof child === \"string\" || attr === undefined) {\n      loose.push(child)\n      return\n    }\n    const name = slotName(attr.slice(\":slot.\".length))\n    // first wins, like two <template name=\"X\"> in one file: a duplicate is a\n    // typo, and the fix is to delete one - not to guess which\n    if (name in contents) {\n      console.warn(`jq79: two <template ${slotAttrName(name)}> in <${node.tag}>; the second was ignored`)\n      return\n    }\n    contents[name] = { nodes: child.children, binder: child.attrs[attr] || undefined }\n  })\n\n  const hasLoose = loose.some(isMeaningful)\n  if (hasLoose && \"default\" in contents) {\n    console.warn(\n      `jq79: <${node.tag}> has both a <template :slot> and content outside it - ` +\n      \"the <template> is the default slot's content, and the rest was ignored\"\n    )\n  } else if (hasLoose) {\n    contents.default = { nodes: loose, binder: node.attrs[\":slot\"] || undefined }\n  }\n  return contents\n}\n\n// `:slot=\"{ item, index: i, total = 0 }\"` - the names the content binds the\n// slot's props to. The bindings are accessors, not values: each read\n// re-evaluates the child's expression, so an effect that reads `item` tracks\n// exactly what that expression touches, on every run (createWithScope's design)\nconst bindSlotProps = (scope: Record<string, any>, binder: string | undefined, props: Record<string, () => any>) => {\n  parsePropsPattern(binder)?.forEach(({ name, as, default: fallback }) => {\n    const local = as ?? name\n    Object.defineProperty(scope, local, {\n      enumerable: true,\n      configurable: true,\n      get: () => {\n        const value = props[name]?.()\n        return value === undefined && fallback !== undefined ? evalExpr(fallback, scope) : value\n      },\n      // a slot prop is the child's value: it arrives on every read and there\n      // is nowhere for a write to go. Silence would be worse - `with` swallows\n      // an assignment to a getter without a word\n      set: () => console.warn(`jq79: \"${local}\" is a slot prop - it comes from the component, so assigning to it does nothing`),\n    })\n  })\n}\n\n// a <template :slot> only fills a slot as a direct child of a component tag,\n// where the usage site takes it out of the children before they are ever\n// rendered (see partitionSlots). Anywhere else the position is a mistake, and\n// rendering the content in place - in the wrong scope, into a <template>\n// nobody clones - would be a strange way to say so. A comment rather than\n// nothing: an :if branch needs a node to hold on to (see boundsOf)\nconst misplacedSlotContent = (node: TemplateNode): Node => {\n  const attr = slotAttrOf(node)\n  console.warn(`jq79: <template ${attr}> fills a slot only as a direct child of a component tag; here it rendered nothing`)\n  return document.createComment(`misplaced ${attr}`)\n}\n\n// what a usage site hands its instance: every slot it filled, as the thunk\n// that renders it. Built once per site, and in one call - a component tag is\n// on the stack while its whole subtree renders below it (a component that\n// renders itself does this 200 deep), so the intermediates stay in here rather\n// than in the frame that waits\nconst buildSlots = (node: TemplateNode, scope: Record<string, any>): SlotMap | null => {\n  const contents = Object.entries(partitionSlots(node))\n  if (!contents.length) return null\n  const slots: SlotMap = {}\n  contents.forEach(([name, content]) => { slots[name] = makeSlotRenderer(content, scope) })\n  return slots\n}\n\n// the thunk one slot's content becomes: the usage site closes over its AST and\n// its scope, the child calls it wherever (and however many times) it renders\n// the matching <slot>\nconst makeSlotRenderer = (content: SlotContent, parentScope: Record<string, any>): SlotRenderer =>\n  (props, slotScope, fx, shadow) => {\n    // the parent's scope, plus the names the content declared for the slot's\n    // props (rule 1: what the content says is decided where it was written)\n    const scope: Record<string, any> = Object.create(parentScope)\n    bindSlotProps(scope, content.binder, props)\n    // this content reads the parent's store (its own names) and the child's\n    // (through the slot props), so every effect created anywhere inside it is\n    // registered with both - see ALSO_WAKEN_BY. Appended rather than assigned:\n    // content forwarded through a <slot> inside slot content is still woken by\n    // the store it came from\n    const inherited: Record<string, any>[] = (scope as any)[ALSO_WAKEN_BY] ?? []\n    Object.defineProperty(scope, ALSO_WAKEN_BY, { value: [...inherited, slotScope] })\n\n    const contentFx = createEffectScope(scope)\n    // rule 3: the <slot> is the content's lifetime. When the child's subtree at\n    // this position goes - an :if turning false, the instance being replaced,\n    // the whole child being destroyed - the content's effects go with it\n    fx.onDispose(() => contentFx.dispose())\n    return renderNodes(content.nodes, scope, contentFx, shadow)\n  }\n\n// <slot />, <slot.name>fallback</slot.name>: where the parent's content goes.\n// Unfilled, the slot renders its own children instead - in this component's\n// scope, since that content is this component's. Every attribute that isn't a\n// directive is a slot prop: `:item=\"item\"` evaluates here and reaches the\n// content under the name it declared, a plain attribute passes a literal\n// string, and there are no reserved names (the slot's own name is in the tag).\n// Bracketed by anchors like a nested component, so the chunk has stable bounds\n// even when it renders nothing (see boundsOf)\nconst renderSlot = (node: TemplateNode, scope: Record<string, any>, fx: EffectScope, shadow: boolean): Node => {\n  const name = slotName(node.tag.slice(\"slot.\".length))\n  const wrapper = document.createDocumentFragment()\n  const anchor = document.createComment(node.tag)\n  const endAnchor = document.createComment(`/${node.tag}`)\n  wrapper.append(anchor, endAnchor)\n\n  const render = (scope as any)[SLOTS]?.[name] as SlotRenderer | undefined\n  if (!render) {\n    wrapper.insertBefore(renderNodes(node.children, scope, fx, shadow), endAnchor)\n    return wrapper\n  }\n\n  const props: Record<string, () => any> = {}\n  Object.entries(node.attrs).forEach(([attr, value]) => {\n    // the scope stamp is the component's, not a prop; @events have no element\n    // to bind here; and a directive means what it means everywhere else -\n    // :if/:each/:with decide whether and how often this slot renders, so they\n    // are the renderer's, not the content's\n    if (attr === SCOPE_ATTR || isControlAttr(attr) || attr.startsWith(\"@\")) return\n    if (attr.startsWith(\":\")) {\n      const expr = value || attr.slice(1)\n      props[kebabToCamel(attr.slice(1))] = () => evalExpr(expr, scope)\n    } else {\n      props[kebabToCamel(attr)] = () => value\n    }\n  })\n\n  wrapper.insertBefore(render(props, scope, fx, shadow), endAnchor)\n  return wrapper\n}\n\n// <MyComponent :user :title=\"'str'\"></MyComponent> - renders a child\n// component instance at this position. Props: `:name=\"expr\"` evaluates expr\n// in the parent scope (`:name` alone is shorthand for `:name=\"name\"`), plain\n// attributes pass through as literal strings, and kebab-case prop names\n// become camelCase. Props stay live: a parent effect re-evaluates each\n// expression and writes it into the child's store. The component variable is\n// reactive too - while it's undefined (e.g. an `await import(...)` still in\n// flight) nothing renders, and the child appears when it resolves.\n// `shadow` is the parent's style mode, carried down the whole render: a child\n// of a shadow-rendered component renders inside that shadow root, so its\n// <style> has to go in there with it - document.head can't reach into a shadow\n// tree, and a style that never applies to its own component would still be\n// restyling the page around it\nconst renderNestedComponent = (key: string, node: TemplateNode, scope: Record<string, any>, fx: EffectScope, shadow: boolean): Node => {\n  // two anchors bracketing everything this usage site ever renders: the\n  // instance's DOM is dynamic (the definition can resolve late or be swapped),\n  // so a caller that needs to move or remove this chunk later can't hold any\n  // of it - it holds the anchors, which never move on their own (see boundsOf)\n  const anchor = document.createComment(key)\n  const endAnchor = document.createComment(`/${key}`)\n  const wrapper = document.createDocumentFragment()\n  wrapper.append(anchor, endAnchor)\n\n  // the tag's children, as content for the child's <slot>s. Built once per\n  // usage site (the AST doesn't change) and closed over the parent's scope\n  // here, so every instance this site ever renders is handed the same thunks\n  const slots = buildSlots(node, scope)\n\n  const props: Record<string, string> = {} // prop name -> expression in parent scope\n  const models: Record<string, string> = {} // model name -> assignable expression in parent scope\n  const events: Array<[string, string]> = [] // @attr (modifiers included) -> handler expression\n  // named props AND spreads in source order - what a :props merge folds over so\n  // precedence follows the JS object-spread rule (later wins). `name` absent\n  // marks a spread: the whole object's properties, not one binding\n  const sources: Array<{ name?: string; expr: string }> = []\n  let hasSpread = false\n  Object.entries(node.attrs).forEach(([attr, value]) => {\n    // the parent's scope stamp is stamped on every template element, this tag\n    // included - it's not a prop, and the child renders under its own scope\n    if (attr === SCOPE_ATTR) return\n    if (attr === \":props\" || attr.startsWith(\":props.\")) {\n      // :props=\"obj\" spreads obj's own properties as props; :props.<n> is one\n      // spread among several (the `...obj` sugar rewrites to it - see\n      // expandPropsSpread), the suffix only keeping the attribute names distinct\n      hasSpread = true\n      sources.push({ expr: value })\n      return\n    }\n    if (isControlAttr(attr)) return\n    if (attr.startsWith(\"@\")) {\n      events.push([attr, value])\n    } else if (attr === \":model\" || attr.startsWith(\":model.\")) {\n      // :model[.name]=\"expr\" - two-way: a prop down plus a writeback listener\n      // (wired below, once the instance exists). The modifier arrives\n      // kebab-case whichever way it was authored (expandNameCase rewrote any\n      // camelCase before parsing); the bare :model binds the name \"default\"\n      const name = attr === \":model\" ? \"default\" : kebabToCamel(attr.slice(\":model.\".length))\n      models[name] = value || (attr === \":model\" ? \"model\" : name)\n    } else if (attr.startsWith(\":\")) {\n      const name = kebabToCamel(attr.slice(1))\n      props[name] = value || name\n      sources.push({ name, expr: value || name })\n    } else {\n      const name = kebabToCamel(attr)\n      const expr = JSON.stringify(value)\n      props[name] = expr\n      sources.push({ name, expr })\n    }\n  })\n\n  // each model is also a prop down: the child reads the value under the\n  // model's name - `model` for the default, because a prop named `default`\n  // could never be read from a child expression (reserved word). Without the\n  // prop this isn't two-way, it's upward collection: a parent reset or an\n  // initial value would never reach the child\n  const modelAttr = (name: string) => (name === \"default\" ? \":model\" : `:model.${name}`)\n  const modelProp = (name: string) => (name === \"default\" ? \"model\" : name)\n  // the newline keeps `= $value` out of a trailing line comment in the\n  // expression (:model=\"uname // the username\") - glued on the same line,\n  // the assignment would vanish into the comment and compile as a bare read,\n  // dropping every update without a word\n  const assignment = (expr: string) => `${expr}\\n= $value`\n  // the models whose expression will never take an update, decided here rather\n  // than at update time: an assignment that landed and one that was dropped\n  // both evaluate to the value assigned, so the result can't tell them apart -\n  // which is what $updateModel's return has to report\n  const unassignable = new Set<string>()\n  Object.entries(models).forEach(([name, expr]) => {\n    const prop = modelProp(name)\n    if (props[prop] !== undefined) {\n      console.warn(`jq79: <${node.tag}> binds prop \"${prop}\" through both :${prop} and ${modelAttr(name)} - ${modelAttr(name)} wins`)\n    }\n    props[prop] = expr\n    // an expression that can't be an assignment target is a wiring mistake -\n    // say so now, not on the first update that silently goes nowhere\n    if (compileExpr(assignment(expr), [\"$value\"]) === null) {\n      unassignable.add(name)\n      console.warn(`jq79: ${modelAttr(name)}=\"${expr}\" is not assignable - updates from <${node.tag}> will be dropped`)\n    }\n  })\n\n  // the full prop set the child gets, resolved in source order: each named prop\n  // sets one key, each spread merges an object's own properties, later sources\n  // overwriting earlier (the JS object-spread rule). :model bindings apply last,\n  // so they win - the same precedence the collision warning above promises. A\n  // spread expression that isn't an object contributes nothing (fail closed,\n  // like :with), so an `await`-pending object spreads once it resolves\n  const resolveProps = (): Record<string, any> => {\n    const out: Record<string, any> = {}\n    sources.forEach(({ name, expr }) => {\n      if (name !== undefined) out[name] = evalExpr(expr, scope)\n      else {\n        const obj = evalExpr(expr, scope)\n        if (obj !== null && typeof obj === \"object\") Object.assign(out, obj)\n      }\n    })\n    Object.entries(models).forEach(([name, expr]) => { out[modelProp(name)] = evalExpr(expr, scope) })\n    return out\n  }\n\n  let current: Component79 | null = null\n  let currentDef: Component79 | null = null\n  let childFx: EffectScope | null = null\n\n  // a usage site that resolves to no component renders nothing, which is\n  // deliberate - `undefined` while an `await import(...)` is in flight has to\n  // wait quietly, and the child appears when it lands. Two cases can never\n  // resolve, though, and both are wiring mistakes worth naming: a value that\n  // isn't a component (and so will never become one by waiting), and a name\n  // the component declared as a prop that the parent passed nothing for. Once\n  // each, per usage site: an effect re-runs\n  const reported = new Set<string>()\n  const reportUnresolved = (value: any) => {\n    if (value === undefined || value === null) {\n      const unfilled: Set<string> | undefined = (scope as any)[UNFILLED_PROPS]\n      if (!unfilled?.has(key) || reported.has(\"unfilled\")) return\n      reported.add(\"unfilled\")\n      console.error(\n        `jq79: <${node.tag}> is declared as a prop and the parent passed nothing - nothing renders here. ` +\n        `Pass it (:${key}=\"…\"), or drop it from the signature to use the one declared in this file.`\n      )\n      return\n    }\n    if (reported.has(\"type\")) return\n    reported.add(\"type\")\n    console.error(`jq79: <${node.tag}> is ${typeof value}, not a component - nothing renders here`)\n  }\n\n  fx.effect(() => {\n    const value = evalExpr(key, scope)\n    const nextDef = value instanceof Component79 ? value : null\n    if (!nextDef) reportUnresolved(value)\n    if (nextDef === currentDef) return\n\n    childFx?.dispose()\n    childFx = null\n    current?.destroy() // detaches its marker range, removing the child's DOM\n    current = null\n    currentDef = nextDef\n    if (!nextDef) return\n\n    // a fresh instance per usage site: the definition's parsed parts (and\n    // pre-resolved modules) are shared, but store/effects/DOM are per instance\n    const instance = new Component79({\n      template: nextDef.template,\n      scripts: nextDef.scripts,\n      styles: nextDef.styles,\n      modules: nextDef.modules,\n      filename: nextDef.filename,\n      // its file's other components, and which of them it is: without the\n      // first a child rendered here loses the siblings its definition could\n      // see, and without the second hot reload can't tell it what it is\n      siblings: nextDef.siblings,\n      name: nextDef.name,\n    })\n    // the content this site wrote inside the tag, before the first render: a\n    // <slot> is resolved while rendering, so the map has to be there by then\n    if (slots) instance.slots = slots\n    // the writeback half of :model - the function the child's $updateModel\n    // calls, handed over before the first render. Not an event: nothing about\n    // a parent-child assignment wants a CustomEvent bubbling through the page\n    // on every keystroke, and a direct call has no payload shape to get wrong.\n    // The name is normalized like the attribute was (kebab->camel; absent\n    // means the default model), and a name nothing binds warns: a typo must\n    // not be an input that types into the void\n    if (Object.keys(models).length) {\n      // each mistake is warned once per instance, not once per keystroke: an\n      // input updating a typo'd name would otherwise flood the console on\n      // every character typed into it\n      const warned = new Set<string>()\n      instance.modelWriteback = (rawName, value) => {\n        const name = rawName == null ? \"default\" : kebabToCamel(String(rawName))\n        const expr = models[name]\n        if (expr === undefined) {\n          if (!warned.has(name)) {\n            warned.add(name)\n            console.warn(`jq79: <${node.tag}> has no ${modelAttr(name)} - bound: ${Object.keys(models).map(modelAttr).join(\", \")}`)\n          }\n          return false\n        }\n        if (unassignable.has(name)) return false // already warned, at wiring time\n        // untracked, like the tag handlers: a child updating from its setup\n        // script runs inside the parent's *creation* effect, and the reads a\n        // path assignment makes (`user` in `user.name = $value`) would land\n        // in its deps - donating that effect one wasted (guard-stopped) wake\n        // per later write. An imperative writeback is nobody's dependency\n        untracked(() => evalExpr(assignment(expr), scope, { $value: value }))\n        return true\n      }\n    }\n\n    // @event on the tag listens to this instance's $emit channel (and only\n    // this instance's - a grandchild's emit arrives here solely as an\n    // explicit re-emit)\n    events.forEach(([attr, expr]) => wireTagEvent(instance, attr, expr, scope))\n\n    // what this component actually takes, decided by its signature. Applied to\n    // every path that writes a prop - the seed here and both sync paths below -\n    // or an undeclared name would be filtered on the first render and reappear\n    // on the next update\n    const declared = declaredPropSet(instance.scripts)\n    warnUndeclared(node, key, Object.keys(props), declared)\n    const seed = pickDeclared(untracked(resolveProps), declared)\n    // mounting into a fragment attaches no shadow root of its own: a\n    // shadow-rendered child keeps its <style> elements inline, next to the DOM\n    // they style, and the parent's shadow root is what scopes both\n    const holder = document.createDocumentFragment()\n    // rendering a child happens on this same stack, so a component that\n    // renders itself recurses as deep as its data does - and a cycle in that\n    // data would recurse until the JS stack gave out, ~900 identical frames\n    // naming nothing. Cut and named instead, exactly like the effect runner\n    // cuts an effect that wakes itself\n    if (nestingDepth >= MAX_NESTING_DEPTH) {\n      console.error(\n        `jq79: <${node.tag}> is ${MAX_NESTING_DEPTH} levels deep inside itself; giving up here. ` +\n        \"A component that renders itself stops when its data stops - is there a cycle in it?\"\n      )\n      return\n    }\n    nestingDepth++\n    try {\n      ;(shadow ? instance.renderShadow(seed) : instance.render(seed)).mount(holder)\n    } finally {\n      nestingDepth--\n    }\n    endAnchor.parentNode!.insertBefore(holder, endAnchor)\n\n    // deep: a prop sync forwards whatever the expression evaluates to, whole,\n    // into the child's store - it reads `user`, never `user.name`, so it can't\n    // track what it passes on. A parent's deep mutation reaches the child\n    // through this effect or not at all (see $effect's `deep`)\n    const syncFx = createEffectScope(scope, true)\n    // without a spread the prop set is fixed and known: one effect per prop, so\n    // a change to one prop re-syncs only that prop. A spread's key set is\n    // dynamic and its precedence is positional, so it can't be resolved a key at\n    // a time across independent effects (whichever re-ran last would win) - one\n    // effect re-merges everything in order and writes the diff, clearing keys a\n    // spread has dropped since last run. Named props are always in the merge, so\n    // they're never cleared; the extra cost is confined to spread-using tags\n    if (hasSpread) {\n      let written: string[] = []\n      syncFx.effect(() => {\n        const next = pickDeclared(resolveProps(), declared)\n        const nextKeys = Object.keys(next)\n        written.forEach(key => { if (!(key in next)) (instance.data as Record<string, any>)[key] = undefined })\n        nextKeys.forEach(key => { (instance.data as Record<string, any>)[key] = next[key] })\n        written = nextKeys\n      })\n    } else {\n      Object.entries(props).forEach(([name, expr]) => {\n        if (declared !== null && !declared.has(name)) return\n        syncFx.effect(() => { (instance.data as Record<string, any>)[name] = evalExpr(expr, scope) })\n      })\n    }\n\n    childFx = syncFx\n    current = instance\n  })\n\n  fx.onDispose(() => {\n    childFx?.dispose()\n    current?.destroy()\n  })\n\n  return wrapper\n}\n\n// :with=\"expr\" narrows the scope for an element and its subtree: names\n// resolve against the expression's value first, then fall back to the outer\n// scope. The value is re-evaluated lazily on every name lookup (never\n// snapshotted), so an effect reading through this proxy tracks both the\n// expression's own dependencies and the property it reads - replacing the\n// object or mutating one of its properties re-renders exactly the dependents,\n// without rebuilding the subtree. Assignments to names the object owns write\n// through to it (reactively, if it came from a store); everything else\n// behaves as if the :with weren't there\nconst createWithScope = (expr: string, scope: Record<string, any>): Record<string, any> => {\n  const source = (): Record<string, any> | null => {\n    const value = evalExpr(expr, scope)\n    return value !== null && typeof value === \"object\" ? value : null\n  }\n  return new Proxy(scope, {\n    has(target, key) {\n      const obj = source()\n      return (obj !== null && Reflect.has(obj, key)) || Reflect.has(target, key)\n    },\n    get(target, key) {\n      const obj = source()\n      if (obj !== null && Reflect.has(obj, key)) return obj[key as string]\n      return Reflect.get(target, key)\n    },\n    set(target, key, value) {\n      const obj = source()\n      if (obj !== null && Reflect.has(obj, key)) {\n        obj[key as string] = value\n        return true\n      }\n      return Reflect.set(target, key, value)\n    },\n  })\n}\n\n// what :class accepts, flattened to single class tokens: a string of\n// space-separated names, an array (entries normalized recursively), or an\n// object whose truthy-valued keys are the names (a key may itself hold\n// several). Everything else - null, false, numbers - contributes nothing, so\n// `cond && 'active'` reads naturally. The object form reads each value, so a\n// store-backed flag is tracked per key\nconst classNames = (value: any): string[] => {\n  if (typeof value === \"string\") return value.split(/\\s+/).filter(Boolean)\n  if (Array.isArray(value)) return value.flatMap(classNames)\n  if (value !== null && typeof value === \"object\")\n    return Object.entries(value).flatMap(([name, on]) => (on ? classNames(name) : []))\n  return []\n}\n\n// what :html.allowed accepts, normalized to an AllowUrl predicate: host\n// patterns (a comma-separated string or an array - see allowedHosts in\n// ./dom) or a function (url: URL, tag, attr) => boolean. Anything else -\n// including a policy expression that evaluates to undefined - denies every\n// destination: the attribute declares the intent to restrict, so a broken\n// policy fails closed, and so does a predicate that throws\nconst normalizeAllowUrl = (policy: any): AllowUrl => {\n  if (typeof policy === \"function\") {\n    return (url, tag, attr) => {\n      try {\n        return !!policy(url, tag, attr)\n      } catch {\n        return false\n      }\n    }\n  }\n  if (typeof policy === \"string\" || Array.isArray(policy)) return allowedHosts(policy)\n  return () => false\n}\n\n// HTML's boolean attributes, verbatim from the spec's list. Presence is the\n// whole message for these: `disabled=\"false\"` and `disabled=\"0\"` both disable,\n// so the value they carry is noise. This is a table of a fact, not of a jq79\n// convention - nobody in this repo decides what belongs in it, which is what\n// earns it a place in a codebase that otherwise has no name tables\nconst BOOLEAN_ATTRS = new Set([\n  \"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"controls\",\n  \"default\", \"defer\", \"disabled\", \"formnovalidate\", \"inert\", \"ismap\",\n  \"itemscope\", \"loop\", \"multiple\", \"muted\", \"nomodule\", \"novalidate\", \"open\",\n  \"playsinline\", \"readonly\", \"required\", \"reversed\", \"selected\",\n])\n\n// the one value rule, shared by `:attr=\"expr\"` and `:attrs` so the two forms\n// can never disagree:\n//\n// - a boolean attribute is removed by ANY falsy value and set to \"\" when\n//   truthy, so `:disabled=\"items.length\"` enables the button on an empty list\n//   (with `value !== false` as the only test, 0 set the attribute and disabled\n//   it - the trap renderComponent.test.ts used to pin);\n// - every other attribute is removed only by null/undefined, so `false`, `0`\n//   and `\"\"` are written. `aria-expanded=\"false\"` and a `data-` flag mean\n//   something that absent cannot say.\n//\n// Asking the DOM which family a name belongs to (`typeof el[name] ===\n// \"boolean\"`) is deliberately not what this does: jsdom and Chrome disagree on\n// `autofocus` and every `aria-*`, so the tests would pin a semantics the\n// browser doesn't have - and `readonly`/`novalidate`/`ismap` reflect under\n// camelCase property names no kebab->camel pass can produce, failing toward\n// `readonly=\"false\"`, which is read-only\nconst applyAttr = (el: Element, name: string, value: any) => {\n  const boolean = BOOLEAN_ATTRS.has(name)\n  if (boolean ? !value : value == null) el.removeAttribute(name)\n  else el.setAttribute(name, boolean ? \"\" : String(value))\n}\n\n// renders a single element node: static attrs, @event listeners, a reactive\n// :attrs object, and its content - :text/:html override the element's own\n// children with a reactive textContent/innerHTML, otherwise children render\n// normally. :if/:elseif/:else/:each are handled by renderNodes, which decides\n// *whether*/*how many times* a node is rendered before calling this. Tags\n// matching a PascalCase scope variable render as nested components instead\nconst renderNode = (node: TemplateNode, outerScope: Record<string, any>, fx: EffectScope, shadow: boolean): Node => {\n  // :with applies to the element's own bindings (@events, :attrs) and its\n  // whole subtree. On a :each element the item scope is already in place, so\n  // :with=\"item\" works\n  const withExpr = node.attrs[\":with\"]\n  const scope = withExpr !== undefined ? createWithScope(withExpr, outerScope) : outerScope\n\n  // before the component-key scan, so <slot> is <slot> even in a file that\n  // happens to have a component named Slot in scope: the tag is the library's\n  // now, and a name that resolved it away would be a very quiet surprise\n  if (isSlotTag(node.tag)) return renderSlot(node, scope, fx, shadow)\n  if (node.tag === \"template\" && slotAttrOf(node) !== undefined) return misplacedSlotContent(node)\n\n  const componentKey = findComponentKey(scope, node.tag)\n  if (componentKey) return renderNestedComponent(componentKey, node, scope, fx, shadow)\n\n  const el = document.createElement(node.tag)\n\n  // <UserCrad /> - written as a component (node.component), resolving to no\n  // component, and not an element either. Nothing else on the page can supply\n  // the name once every script has settled, so this renders no markup, no\n  // styles, no children and no script, forever, and says so by throwing rather\n  // than leaving a hole where a region of the page was meant to be.\n  //\n  // All three conditions carry weight. Without the capitalization <lable> and\n  // <svg> would be fatal (createElement builds SVG names in the HTML namespace,\n  // so an <svg> is an HTMLUnknownElement too); without the element check <DIV>\n  // would be, though it renders a perfectly good div; and without the pending\n  // count a factory that awaits $mounted() before returning its components\n  // could never render one, which is exactly what the watcher below is for.\n  //\n  // An *absent* count is a fourth case, and it is not zero: renderComponent()\n  // renders a template against a store somebody else owns and assembles, so\n  // nothing there has finished and nothing says a key can't still be written\n  // in. The claim being tested is a component's claim about its own scripts,\n  // and where none was made the tag waits for the upgrade, as it always has.\n  //\n  // Written without a local for the count because renderNode is on the stack\n  // for the whole of the subtree below it, so a slot here is a slot per level\n  // of a component nested inside itself - see renderWith\n  if (node.component && el instanceof HTMLUnknownElement && ((scope as any)[PENDING_SCRIPTS] as PendingScripts | undefined)?.count === 0) {\n    throw unresolvedComponent(node.component, scope)\n  }\n\n  // a tag that isn't standard HTML but has no matching scope key *yet* may be\n  // a component that arrives later (e.g. an async factory script exposing an\n  // imported component after `await`). Watch for the key: the effect tracks\n  // no deps, so it only re-runs on the store's new-key sweep, and swaps the\n  // placeholder element for the component exactly once\n  // dashes included, because findComponentKey matches them case-insensitively\n  // with dashes stripped: <drop-area> resolves DropArea, so a dashed tag is a\n  // possible component too, not only a custom element\n  const mayUpgrade = el instanceof HTMLUnknownElement || node.tag.includes(\"-\")\n  if (mayUpgrade) {\n    let upgraded = false\n    fx.effect(() => {\n      if (upgraded) return\n      const key = findComponentKey(scope, node.tag)\n      if (!key) return\n      upgraded = true\n      const replacement = renderNestedComponent(key, node, scope, fx, shadow)\n      // whoever tears this subtree down holds `el`, which the swap detaches -\n      // so the component's anchors must remove themselves when the scope goes\n      const range = boundsOf(replacement)\n      fx.onDispose(() => removeRange(range))\n      el.replaceWith(replacement)\n    })\n  }\n\n  Object.entries(node.attrs).forEach(([key, value]) => {\n    if (key.startsWith(\"@\")) bindEvent(el, key, value, scope)\n    else if (key === \":model\" || key.startsWith(\":model.\")) {\n      // :model binds component tags only (see TODOS/2026-07-15.model-directive.md;\n      // the native-element form is parked there). Warn on a real element, but\n      // not on a tag that may still upgrade into a component - the upgrade\n      // re-renders through renderNestedComponent, models and all\n      if (!mayUpgrade) {\n        console.warn(`jq79: ${key} on <${node.tag}> does nothing - :model binds component tags only (for now)`)\n      }\n    } else if (isControlAttr(key)) {\n      // a directive of its own, bound further down (or by renderNodes)\n    } else if (key.startsWith(\":\")) {\n      // :name=\"expr\" binds that one attribute, reactively - the single-key\n      // case :attrs=\"{ name: expr }\" was carrying. `:name` alone is shorthand\n      // for `:name=\"name\"`, like props and :model.<name>, and the shorthand\n      // reads the camelCase variable while the attribute keeps its written\n      // (kebab) name: `:aria-expanded` binds `ariaExpanded`, because\n      // `aria-expanded` as an expression is a subtraction.\n      //\n      // On a tag that may still upgrade this is a *parameter*, not an\n      // attribute: leave it written verbatim, as before, so the upgrade's\n      // renderNestedComponent still finds it. A component tag has no single\n      // root for an attribute to land on anyway (TODOS/2026-07-15.class-directive.md)\n      if (mayUpgrade) el.setAttribute(key, value)\n      else {\n        const name = key.slice(1)\n        const expr = value || kebabToCamel(name)\n        fx.effect(() => applyAttr(el, name, evalExpr(expr, scope)))\n      }\n    } else el.setAttribute(key, value)\n  })\n\n  const bindExpr = node.attrs[\":attrs\"]\n  if (bindExpr !== undefined) {\n    let boundKeys: string[] = []\n\n    fx.effect(() => {\n      boundKeys.forEach(key => el.removeAttribute(key))\n      const bound = evalExpr(bindExpr, scope)\n      boundKeys = bound && typeof bound === \"object\" ? Object.keys(bound) : []\n      boundKeys.forEach(key => applyAttr(el, key, bound[key]))\n    })\n  }\n\n  // :class=\"expr\" adds classes on top of the static `class` attribute, and\n  // :class.<name>=\"expr\" is the single-flag shorthand for `{ <name>: expr }`\n  // (the name routed through classNames, so an empty `:class.` can't reach\n  // classList.add, which throws on \"\"). Both feed one effect and one set of\n  // added classes: only classes this binding added are ever removed, so the\n  // static list survives every re-run, even when the expression names one of\n  // its classes and then drops it (class=\"btn\" :class=\"{ btn: cond }\" keeps\n  // btn on false)\n  const classExpr = node.attrs[\":class\"]\n  const classToggles = Object.entries(node.attrs)\n    .filter(([key]) => key.startsWith(\":class.\"))\n    .map(([key, expr]): [string, string] => [key.slice(\":class.\".length), expr])\n  if (classExpr !== undefined || classToggles.length) {\n    const staticClasses = new Set(classNames(node.attrs.class ?? \"\"))\n    let bound: string[] = []\n\n    fx.effect(() => {\n      const next = classExpr !== undefined ? classNames(evalExpr(classExpr, scope)) : []\n      classToggles.forEach(([name, expr]) => {\n        if (evalExpr(expr, scope)) next.push(...classNames(name))\n      })\n      bound.forEach(name => {\n        if (!next.includes(name) && !staticClasses.has(name)) el.classList.remove(name)\n      })\n      el.classList.add(...next)\n      bound = next\n    })\n  }\n\n  // :text=\"expr\" sets textContent reactively, replacing any children.\n  // :html=\"expr\" sets innerHTML reactively, sanitizing the value first so\n  // untrusted content can't inject scripts/attributes (see sanitizeHTML in\n  // ./dom). Both skip rendering the element's own children/interpolation.\n  // :html.allowed=\"expr\" adds a destination policy for the content's\n  // href/src URLs - evaluated in the same effect, so a policy held in the\n  // store is as reactive as the content itself\n  const textExpr = node.attrs[\":text\"]\n  const htmlExpr = node.attrs[\":html\"]\n  const allowedExpr = node.attrs[\":html.allowed\"]\n  if (allowedExpr !== undefined && htmlExpr === undefined) {\n    console.warn(\"jq79: :html.allowed without :html on the same element does nothing\")\n  }\n  if (textExpr !== undefined) {\n    fx.effect(() => { el.textContent = String(evalExpr(textExpr, scope) ?? \"\") })\n  } else if (htmlExpr !== undefined) {\n    fx.effect(() => {\n      const options = allowedExpr !== undefined ? { allowUrl: normalizeAllowUrl(evalExpr(allowedExpr, scope)) } : undefined\n      el.innerHTML = sanitizeHTML(String(evalExpr(htmlExpr, scope) ?? \"\"), options)\n    })\n  } else if (el instanceof HTMLTemplateElement) {\n    // a plain nested <template> stays what HTML says it is: an inert element\n    // whose children live in .content, which is where whoever clones it looks\n    // for them. They render (bindings and all) and go there - appended as\n    // childNodes they would be in the DOM but in no document fragment, seen by\n    // nothing and rendered by nobody\n    renderNodes(node.children, scope, fx, shadow, el.content)\n  } else {\n    renderNodes(node.children, scope, fx, shadow, el)\n  }\n\n  // :value / :checked / :selected write the DOM *property*, not the\n  // attribute - the attribute is only a form control's default, and detaches\n  // the moment the user interacts (which is why :attrs=\"{ value }\" stops\n  // driving a typed-in input). One-way, store -> DOM: the way back stays an\n  // explicit @input/@change. :value skips the write when the property\n  // already holds the string, so an unrelated re-run can't move the caret of\n  // the input the user is typing into. Registered after the children render:\n  // :value on a <select> can only pick an <option> that already exists\n  const valueExpr = node.attrs[\":value\"]\n  if (valueExpr !== undefined) {\n    fx.effect(() => {\n      const value = String(evalExpr(valueExpr, scope) ?? \"\")\n      if ((el as HTMLInputElement).value !== value) (el as HTMLInputElement).value = value\n    })\n  }\n  ;([\":checked\", \":selected\"] as const).forEach(attr => {\n    const expr = node.attrs[attr]\n    if (expr === undefined) return\n    const prop = attr.slice(1) as \"checked\" | \"selected\"\n    fx.effect(() => { (el as any)[prop] = !!evalExpr(expr, scope) })\n  })\n\n  return el\n}\n\n// a :if/:elseif*/:else? chain sharing one anchor comment so the active branch\n// can be swapped in place without disturbing sibling positions. Only depends\n// on whatever the branch expressions read (e.g. \"score\"), and skips\n// rebuilding entirely when the active branch hasn't actually changed\nconst renderConditional = (branches: ConditionalBranch[], scope: Record<string, any>, fx: EffectScope, shadow: boolean): Node => {\n  const anchor = document.createComment(\"if\")\n  const wrapper = document.createDocumentFragment()\n  wrapper.appendChild(anchor)\n\n  let current: NodeRange | null = null\n  let activeBranch: ConditionalBranch | null = null\n  let branchFx: EffectScope | null = null\n\n  fx.effect(() => {\n    const next = branches.find(branch => branch.expr === undefined || evalExpr(branch.expr, scope)) ?? null\n    if (next === activeBranch) return\n\n    branchFx?.dispose()\n    if (current) removeRange(current)\n    current = null\n    activeBranch = next\n    if (!next) return\n\n    branchFx = createEffectScope(scope)\n    // bounds captured before inserting: a component branch is a fragment, and\n    // inserting it is what empties it (see boundsOf)\n    const rendered = renderNode(next.node, scope, branchFx, shadow)\n    current = boundsOf(rendered)\n    anchor.parentNode!.insertBefore(rendered, anchor.nextSibling)\n  })\n\n  return wrapper\n}\n\n// defines a loop-local binding directly as `scope`'s own property. Plain\n// assignment (scope[key] = value) would only do this if the key isn't\n// already own on `scope` *or anywhere up its prototype chain* - if it isn't,\n// JS delegates the [[Set]] to whatever's up there, which for us is another\n// reactive proxy's `set` trap: it would wrap `value` as if it were a genuine\n// store mutation and fire a bogus notify() under a name (e.g. \"item\") shared\n// by every unrelated item in every :each on the page. defineProperty always\n// writes to `scope` itself, never delegating, so this can't happen\nconst defineScopeVar = (scope: Record<string, any>, key: string, value: any) => {\n  Object.defineProperty(scope, key, { value, writable: true, enumerable: true, configurable: true })\n}\n\ntype EachEntry = { key: any; item: any; scope: Record<string, any>; range: NodeRange; fx: EffectScope }\n\n// what :each iterates besides arrays: dictionaries, as their entries. Class\n// instances, Maps and the rest stay out - the store doesn't wrap them\n// (isPlainData), so their contents wouldn't be tracked and the list would go\n// silently stale\nconst isPlainObject = (value: any): value is Record<string, any> => {\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n\n// :each=\"item in items\" (or \"item, i in items\" / \"(value, key) in props\"),\n// optionally keyed with :key=\"expr\". Only depends on what the list expression\n// reads, and on each run diffs by key: unchanged items (same key, same item\n// reference) keep their DOM/effects, changed/added ones are (re)rendered,\n// removed ones are disposed. Without :key, an array uses position - fine for\n// append-only lists, wasteful for reordering - and an object uses the\n// property key, which is already the stable identity. Each item gets its own\n// scope via Object.create(scope), so the bindings and `$index` shadow\n// same-named outer names without copying the parent scope's keys\n// does anything in this subtree name one of `names` as an identifier? Attribute\n// values and text alike, since either can hold an expression - a prop handing a\n// position to a nested component (`<Row :n=\"$index\">`) is an attribute on a node\n// inside the item, which is why the walk has to cover children's attrs too.\n//\n// Over-approximating is the safe direction and the intended one: a name that\n// appears in a string literal costs a refresh that wasn't needed, which is\n// exactly what happens today for every list. Missing one would leave a binding\n// stale, and the walk cannot - a template expression is source text\nconst mentionsAny = (node: TemplateNode | string, names: string[]): boolean => {\n  if (typeof node === \"string\") return names.some(name => identifierIn(node, name))\n  return Object.values(node.attrs).some(value => names.some(name => identifierIn(value, name))) ||\n    node.children.some(child => mentionsAny(child, names))\n}\n\n// `name` as a whole word: `$index` must not match inside `$indexes`, and `i`\n// must not match inside `items`. `$` counts as a word character here, which is\n// why the boundaries are checked by hand rather than with \\b - \\b treats `$`\n// as a boundary and would find the `i` of `$index` when looking for `i`\nconst IDENTIFIER_CHAR = /[A-Za-z0-9_$]/\n\nconst identifierIn = (text: string, name: string): boolean => {\n  for (let at = text.indexOf(name); at !== -1; at = text.indexOf(name, at + 1)) {\n    const before = at === 0 ? \"\" : text[at - 1]\n    const after = text[at + name.length] ?? \"\"\n    if (!IDENTIFIER_CHAR.test(before) && !IDENTIFIER_CHAR.test(after)) return true\n  }\n  return false\n}\n\nconst renderEach = (node: TemplateNode, scope: Record<string, any>, fx: EffectScope, shadow: boolean): Node => {\n  const match = node.attrs[\":each\"].match(EACH_PATTERN)\n  if (!match) return document.createComment(`invalid :each expression \"${node.attrs[\":each\"]}\"`)\n\n  const [, itemName, atName, listExpr] = match\n  const keyExpr = node.attrs[\":key\"]\n  const { [\":each\"]: _each, [\":key\"]: _key, ...itemAttrs } = node.attrs\n  const itemNode: TemplateNode = { ...node, attrs: itemAttrs }\n\n  // An entry that changed position needs its position-only bindings re-run -\n  // `$index` and the `, at` name are plain scope vars, untracked by design, so\n  // nothing can wake them (see EffectScope.refresh). But refresh re-runs *every*\n  // effect on the entry, and in a list whose template names no position at all\n  // - the common one - all of that recomputes strings that cannot have changed:\n  // it was 9ms of removeRow's 25ms. Decided once, from the template, rather\n  // than per row per render. The item name is deliberately not in this list:\n  // nearly every binding reads it, and it is not what goes stale.\n  // See TODOS/2026-08-23.positional-refresh.md\n  const positionalNames = [\"$index\", ...(atName ? [atName] : [])]\n  const readsPosition = mentionsAny(itemNode, positionalNames)\n\n  const anchor = document.createComment(\"each\")\n  const wrapper = document.createDocumentFragment()\n  wrapper.appendChild(anchor)\n\n  // :if on the same element is not per-item filtering, and rendering\n  // everything in silence reads like a broken filter - say it out loud\n  if (\":if\" in node.attrs || \":elseif\" in node.attrs || \":else\" in node.attrs) {\n    console.warn(\"jq79: :if/:elseif/:else on a :each element is ignored; filter the list expression instead\")\n  }\n\n  let entries: EachEntry[] = []\n  let warnedDuplicates = false\n\n  // one memo for the whole diff: every row resolves its tags to the same scope\n  // keys, so the scan that used to run per element per row now runs once per\n  // distinct tag (see findComponentKey)\n  fx.effect(() => {\n    const pass = openRenderPass(scope)\n    try {\n      const list = evalExpr(listExpr, scope)\n      // both sources normalize to [at, item] pairs: the index for an array, the\n      // property key for a plain object (insertion order). Object entries are\n      // read off the store proxy, so each value is tracked under its own key -\n      // adds, deletes and changes all wake this effect\n      const pairs: [any, any][] = Array.isArray(list)\n        ? list.map((item, index): [any, any] => [index, item])\n        : isPlainObject(list) ? Object.entries(list) : []\n      // buckets rather than a key->entry map: duplicate keys (a user error, but\n      // one that must degrade instead of corrupt) consume entries in order of\n      // appearance, so no entry is ever matched twice - matching one twice is\n      // how a reused row got disposed and a removed one resurrected\n      const previous = new Map<any, EachEntry[]>()\n      entries.forEach(entry => {\n        const bucket = previous.get(entry.key)\n        if (bucket) bucket.push(entry)\n        else previous.set(entry.key, [entry])\n      })\n\n      const seen = new Set<any>()\n      const moved: EachEntry[] = []\n      const nextEntries = pairs.map(([at, item], index): EachEntry => {\n        const itemScope = Object.create(scope)\n        defineScopeVar(itemScope, itemName, item)\n        if (atName) defineScopeVar(itemScope, atName, at)\n        defineScopeVar(itemScope, \"$index\", index)\n        const key = keyExpr !== undefined ? evalExpr(keyExpr, itemScope) : at\n        if (seen.has(key) && !warnedDuplicates) {\n          warnedDuplicates = true\n          console.warn(`jq79: duplicate :key in :each \"${node.attrs[\":each\"]}\"; duplicates pair up by position`)\n        }\n        seen.add(key)\n        const existing = previous.get(key)?.shift()\n\n        if (existing && Object.is(existing.item, item)) {\n          if (readsPosition && existing.scope.$index !== index) moved.push(existing)\n          defineScopeVar(existing.scope, \"$index\", index)\n          if (atName) defineScopeVar(existing.scope, atName, at)\n          return existing\n        }\n\n        if (existing) {\n          existing.fx.dispose()\n          removeRange(existing.range)\n        }\n\n        const itemFx = createEffectScope(scope)\n        // bounds captured before the positioning pass inserts the entry: a\n        // component entry is a fragment, which empties on insertion (see boundsOf)\n        const range = boundsOf(renderNode(itemNode, itemScope, itemFx, shadow))\n        return { key, item, scope: itemScope, fx: itemFx, range }\n      })\n\n      // whatever no new item consumed is gone. Effects are torn down one by one\n      // as always; the DOM goes in runs of neighbours, which is what makes\n      // clearing a long list one mutation instead of one per row\n      const dead = new Set<EachEntry>()\n      previous.forEach(bucket => bucket.forEach(entry => dead.add(entry)))\n      if (dead.size) {\n        dead.forEach(entry => entry.fx.dispose())\n        removeRuns(contiguousRuns(entries, entry => dead.has(entry)))\n      }\n\n      let prevNode: Node = anchor\n      nextEntries.forEach(entry => {\n        if (prevNode.nextSibling !== entry.range.first) moveRangeAfter(entry.range, prevNode)\n        prevNode = entry.range.last\n      })\n\n      // reused entries that changed position: their tracked bindings re-run off\n      // the list notification anyway, but a binding that reads only `$index` or\n      // the named key tracked nothing - refresh them so the move reaches those\n      // too. Untracked, so these runs don't feed this list effect's own deps\n      moved.forEach(entry => untracked(() => entry.fx.refresh()))\n\n      entries = nextEntries\n    } finally {\n      closeRenderPass(pass)\n    }\n  })\n\n  return wrapper\n}\n\n// renders a list of sibling template nodes (text + elements), grouping\n// consecutive :if/:elseif/:else nodes into a single conditional block\n// `into` renders straight into an element that is not in the document yet -\n// what renderElement does for an element's own children. Every element used to\n// get a DocumentFragment of its own, filled and then emptied into it: for a\n// 10,000-row table that is 70,000 fragments and a second pass over every node,\n// and the intermediate is invisible either way because the element is still\n// detached. Callers that need a standalone chunk (a component's content, an\n// :if branch) omit it and get the fragment\nconst renderNodes = <T extends ParentNode>(\n  nodes: (TemplateNode | string)[],\n  scope: Record<string, any>,\n  fx: EffectScope,\n  shadow = false,\n  into?: T\n): T | DocumentFragment => {\n  const fragment = into ?? document.createDocumentFragment()\n  let i = 0\n\n  while (i < nodes.length) {\n    const node = nodes[i]\n\n    if (typeof node === \"string\") {\n      const textNode = document.createTextNode(node)\n      // static text is most of a template (all of its indentation, for a start):\n      // only text with a {{ expression }} in it needs an effect to stay in sync\n      if (node.includes(\"{{\")) fx.effect(() => { textNode.textContent = interpolate(node, scope) })\n      fragment.appendChild(textNode)\n      i++\n      continue\n    }\n\n    if (\":each\" in node.attrs) {\n      fragment.appendChild(renderEach(node, scope, fx, shadow))\n      i++\n      continue\n    }\n\n    if (\":if\" in node.attrs) {\n      const branches: ConditionalBranch[] = [{ expr: node.attrs[\":if\"], node }]\n      i++\n\n      // the branches of a chain are siblings in the AST, but the template writes\n      // them on their own lines - so the whitespace between them is indentation\n      // and nothing else, and it's dropped rather than rendered: only one branch\n      // is ever in the DOM, so there is nothing for it to be a space *between*\n      const nextBranch = (attr: string): TemplateNode | undefined => {\n        let next = i\n        while (next < nodes.length && typeof nodes[next] === \"string\" && !(nodes[next] as string).trim()) next++\n        const candidate = nodes[next]\n        if (typeof candidate === \"object\" && attr in candidate.attrs) {\n          i = next + 1\n          return candidate\n        }\n        return undefined\n      }\n\n      for (let elseif = nextBranch(\":elseif\"); elseif; elseif = nextBranch(\":elseif\")) {\n        branches.push({ expr: elseif.attrs[\":elseif\"], node: elseif })\n      }\n      const elseNode = nextBranch(\":else\")\n      if (elseNode) branches.push({ node: elseNode })\n\n      fragment.appendChild(renderConditional(branches, scope, fx, shadow))\n      continue\n    }\n\n    fragment.appendChild(renderNode(node, scope, fx, shadow))\n    i++\n  }\n\n  return fragment\n}\n\nexport const renderComponent = (component: Component79, data: ReactiveDeepData<Record<string, any>>, shadow = false): Node =>\n  renderNodes(component.template, data, createEffectScope(data), shadow)\n\ntype ComponentParts = {\n  template: TemplateNode[]\n  scripts: TagBlock[]\n  styles: TagBlock[]\n  // pre-resolved modules for `import(...)` calls in setup scripts, keyed by\n  // the literal specifier. Bundlers (the jq79/vite plugin) fill this so\n  // imports resolve from the bundle instead of being fetched at runtime\n  modules?: Record<string, any>\n  // where this component came from (a URL for fetch(), a path for the vite\n  // plugin). Names the setup scripts in devtools - see scriptSourceUrl\n  filename?: string\n  // the components the file's <template name=\"...\"> blocks declared, by name.\n  // Every component parsed out of one file holds this same map - itself\n  // included - which is what makes a sibling usable without an import, and\n  // what lets a <template name=\"TreeNode\"> render a <TreeNode>\n  siblings?: Record<string, Component79>\n  // which of the file's components this is: a template's name, or undefined\n  // for the file's own. The file is the hot-reload unit, so a reparse hands\n  // each live instance the parts belonging to the component it is\n  name?: string\n}\n\nconst VOID_ELEMENTS = new Set([\n  \"area\", \"base\", \"br\", \"col\", \"embed\", \"hr\", \"img\", \"input\",\n  \"link\", \"meta\", \"param\", \"source\", \"track\", \"wbr\",\n])\n\n// a self-closing tag with its attributes; quoted attribute values are matched\n// as whole chunks so a \"/>\" inside one doesn't end the tag early. The tag name\n// admits a dot for the named forms of a tag - <slot.header /> - which is a\n// legal HTML tag name (the tokenizer reads to the first space, \"/\" or \">\")\nconst SELF_CLOSING_RE = /<([A-Za-z][\\w.-]*)((?:\"[^\"]*\"|'[^']*'|[^>\"'])*?)\\/>/g\nconst RAW_BLOCK_RE = /(<script[\\s\\S]*?<\\/script\\s*>|<style[\\s\\S]*?<\\/style\\s*>)/gi\n\n// expands self-closing tags (<MyComponent />, <div />) into explicit\n// open+close pairs BEFORE DOM parsing. The HTML parser ignores the slash and\n// would treat them as unclosed, swallowing the following siblings. Void\n// elements keep their native behavior, and <script>/<style> contents are\n// passed through untouched so code inside them is never rewritten\nconst expandSelfClosingTags = (src: string): string =>\n  src\n    .split(RAW_BLOCK_RE)\n    .map((chunk, i) =>\n      i % 2 === 1 // odd chunks are the captured script/style blocks\n        ? chunk\n        : chunk.replace(SELF_CLOSING_RE, (match, tag: string, attrs: string) =>\n            VOID_ELEMENTS.has(tag.toLowerCase()) ? match : `<${tag}${attrs}></${tag}>`\n          )\n    )\n    .join(\"\")\n\n// a start tag with its attributes, quote-aware so a \">\" inside a value doesn't\n// end it early; and a single spread attribute in name position (preceded by\n// start-or-whitespace), its expression an identifier or member path\nconst OPEN_TAG_RE = /<([A-Za-z][\\w.-]*)((?:\"[^\"]*\"|'[^']*'|[^>\"'])*)>/g\nconst ATTR_SPREAD_RE = /\"[^\"]*\"|'[^']*'|(^|\\s)\\.\\.\\.([A-Za-z_$][\\w$.]*)/g\n\n// `...expr` as an attribute is sugar for :props=\"expr\" (spread an object's\n// properties as props - see renderNestedComponent). Rewritten BEFORE DOM\n// parsing, into a value-based :props.<n>, because the HTML parser lowercases\n// attribute *names*: with the expression in the name, `...userData` would arrive\n// as `...userdata` and resolve to nothing. Moving it into a value - which the\n// parser leaves untouched - keeps camelCase intact. Same pre-parse string move\n// as expandSelfClosingTags, with the same defenses against rewriting code that\n// only looks like a spread: <script>/<style> bodies are split out (a JS `...rest`\n// there is not an attribute), only a start tag's interior is scanned (text\n// between tags is safe), and quoted values are consumed whole so a genuine JS\n// spread in a value (@click=\"f(...args)\", :x=\"{ ...a }\") is skipped. The <n>\n// suffix (per tag) only keeps several spreads' attribute names distinct. A call\n// (`...getProps()`) stops at the paren and is left alone - use :props=\"expr()\"\nconst expandPropsSpread = (src: string): string =>\n  src\n    .split(RAW_BLOCK_RE)\n    .map((chunk, i) =>\n      i % 2 === 1\n        ? chunk\n        : chunk.replace(OPEN_TAG_RE, (_match, tag: string, attrs: string) => {\n            let n = 0\n            const rewritten = attrs.replace(ATTR_SPREAD_RE, (whole, space: string | undefined, expr: string | undefined) =>\n              expr === undefined ? whole : `${space}:props.${n++}=\"${expr}\"`\n            )\n            return `<${tag}${rewritten}>`\n          })\n    )\n    .join(\"\")\n\n// a `:`-prefixed attribute name in name position, and a </slot.name> closing\n// tag. Both quote-aware for the same reason ATTR_SPREAD_RE is: a colon inside\n// a value (@click=\"a ? b : c\", style=\"color: red\") is not an attribute name\nconst ATTR_NAME_RE = /\"[^\"]*\"|'[^']*'|(^|\\s)(:[\\w.$-]+)/g\nconst CLOSE_SLOT_RE = /<\\/slot\\.([\\w.$-]+)(\\s*)>/gi\nconst SLOT_TAG_RE = /^slot\\./i\n\n// camelCase -> kebab-case for every name the HTML parser would lowercase,\n// BEFORE it gets the chance: `:firstName` would arrive as `:firstname` and\n// kebabToCamel (which is what reads these names back out) would have nothing\n// to un-kebab, so the prop, model or slot would silently land under the wrong\n// key. Rewriting to `:first-name` here means both spellings converge on the\n// same camelCase name downstream - the author picks, the runtime doesn't care.\n//\n// Runs FIRST among the pre-parse passes, which is what keeps it simple: it\n// never sees the `:props.<n>` that expandPropsSpread generates, and a\n// <slot.firstName /> is still one occurrence rather than the open+close pair\n// expandSelfClosingTags turns it into. Same defenses as the passes after it -\n// <script>/<style> bodies split out, only start-tag interiors scanned, quoted\n// values consumed whole.\n//\n// Two name positions, not one: attribute names (`:model.firstName`) and the\n// dotted tag names (`<slot.firstName>`), whose closing halves are rewritten\n// too or the parser sees a mismatched pair. Component tags are deliberately\n// left alone - findComponentKey already matches them case-insensitively with\n// dashes stripped, so <UserCard> needs no help and rewriting it would only\n// obscure what the author wrote\nconst kebabTagName = (tag: string): string =>\n  SLOT_TAG_RE.test(tag) ? `slot.${camelToKebab(tag.slice(\"slot.\".length))}` : tag\n\n// the same pass records what it declined to rewrite. An uppercase-initial tag\n// is a claim about a component: HTML's own elements are matched\n// case-insensitively but nobody writes <DIV> by accident, and a custom element\n// may not be spelled that way at all. So <UserCard> is a name the author\n// expected to resolve - which is what lets renderNode throw when it doesn't\n// (see unresolvedComponent).\n//\n// Carried in a *value* rather than left in the tag name, because the value is\n// the one place the HTML parser preserves case - the same move expandPropsSpread\n// makes for `...userData`, and for the same reason. elementToAST lifts it\n// straight off attrs into a field, so no attribute loop downstream ever sees\n// it - and since that lift is unconditional, the name has to be one no author\n// would write: a plain `:component` would eat the prop of that name off\n// <Card :component=\"Widget\" />\nconst COMPONENT_TAG_ATTR = \":jq79-component\"\nconst COMPONENT_TAG_RE = /^[A-Z]/\n\n// appends the stamp inside the tag, *before* a self-closing slash: this pass\n// runs first and expandSelfClosingTags still has to recognize the `/>` that\n// OPEN_TAG_RE swept into the attributes. A slash inside a quoted value can't be\n// mistaken for it - only a trailing one is matched\nconst TRAILING_SLASH_RE = /\\/\\s*$/\n\nconst stampComponentTag = (tag: string, attrs: string): string => {\n  if (!COMPONENT_TAG_RE.test(tag)) return attrs\n  const stamp = ` ${COMPONENT_TAG_ATTR}=\"${tag}\"`\n  const slash = TRAILING_SLASH_RE.exec(attrs)\n  return slash ? `${attrs.slice(0, slash.index)}${stamp}${slash[0]}` : `${attrs}${stamp}`\n}\n\nconst expandNameCase = (src: string): string =>\n  src\n    .split(RAW_BLOCK_RE)\n    .map((chunk, i) =>\n      i % 2 === 1\n        ? chunk\n        : chunk\n            .replace(OPEN_TAG_RE, (_match, tag: string, attrs: string) => {\n              const rewritten = attrs.replace(ATTR_NAME_RE, (whole, space: string | undefined, name: string | undefined) =>\n                name === undefined ? whole : `${space}${camelToKebab(name)}`\n              )\n              return `<${kebabTagName(tag)}${stampComponentTag(tag, rewritten)}>`\n            })\n            .replace(CLOSE_SLOT_RE, (_match, suffix: string, space: string) => `</slot.${camelToKebab(suffix)}${space}>`)\n    )\n    .join(\"\")\n\n// <style scoped> support. Every element of the component's own template is\n// stamped with data-jq79=\"<hash>\" and the style's selectors are rewritten to\n// require that attribute, so its rules can't reach anything the component\n// didn't render. Purely a runtime transform (the browser parses the CSS), so\n// it works the same for a bundled component and one loaded with fetch()\nconst SCOPE_ATTR = \"data-jq79\"\n\n// FNV-1a over the source: stable per definition (not per instance), so N\n// instances of the same component share one refcounted <style> in the head\nconst scopeHash = (src: string): string => {\n  let hash = 2166136261\n  for (let i = 0; i < src.length; i++) hash = Math.imul(hash ^ src.charCodeAt(i), 16777619)\n  return (hash >>> 0).toString(36)\n}\n\nconst stampScope = (nodes: (TemplateNode | string)[], scope: string) => {\n  nodes.forEach(node => {\n    if (typeof node === \"string\") return\n    node.attrs[SCOPE_ATTR] = scope\n    stampScope(node.children, scope)\n  })\n}\n\n// the scope attribute goes on the selector's last compound - the element the\n// rule actually targets - but *before* a pseudo-element, which must stay last\n// (\".a::before\" scopes to \".a[data-jq79='x']::before\", not \"::before[...]\")\nconst scopeSelector = (selectorText: string, scope: string): string =>\n  selectorText\n    .split(\",\")\n    .map(part => {\n      const selector = part.trim()\n      const pseudoAt = selector.indexOf(\"::\")\n      const target = pseudoAt === -1 ? selector : selector.slice(0, pseudoAt)\n      const pseudoElement = pseudoAt === -1 ? \"\" : selector.slice(pseudoAt)\n      return `${target}[${SCOPE_ATTR}=\"${scope}\"]${pseudoElement}`\n    })\n    .join(\", \")\n\n// CSSStyleRule is scoped in place; CSSGroupingRule (@media, @supports,\n// @container) is recursed into; everything else - notably @keyframes, whose\n// \"selectors\" are percentages - is left alone\nconst scopeRules = (rules: CSSRuleList, scope: string) => {\n  Array.from(rules).forEach(rule => {\n    if (rule instanceof CSSStyleRule) rule.selectorText = scopeSelector(rule.selectorText, scope)\n    else if (rule instanceof CSSGroupingRule) scopeRules(rule.cssRules, scope)\n  })\n}\n\n// the CSS parser is the browser's own (no dependency, no hand-rolled parser).\n// Note browsers *silently drop* rules whose selector they can't parse, which\n// is what Vue's :deep()/::v-deep/>>> escape hatches are - unsupported here,\n// and warned about rather than left to vanish\nconst scopeCss = (css: string, scope: string): string => {\n  if (/:deep\\(|::v-deep|>>>/.test(css)) {\n    console.warn(\"jq79: :deep()/::v-deep/>>> are not supported in <style scoped>; the rule will be dropped by the browser\")\n  }\n  const sheet = new CSSStyleSheet()\n  sheet.replaceSync(css)\n  scopeRules(sheet.cssRules, scope)\n  return Array.from(sheet.cssRules).map(rule => rule.cssText).join(\"\\n\")\n}\n\n// a component name has to be PascalCase to be usable: findComponentKey only\n// ever considers capitalized scope keys, so a lowercase name would declare a\n// component no tag could reference. It is also what keeps the named exports\n// from colliding with a definition's own fields, which are all lowercase\nconst COMPONENT_NAME_RE = /^[A-Z][A-Za-z0-9]*$/\n\n// converts a string of HTML into an AST representation of the component:\n// - template: the non-script/style top-level elements, as TemplateNodes\n// - scripts/styles: { attrs, content } blocks in source order\n// - siblings: the components its top-level <template name=\"...\"> declared\nconst parseComponentString = (component: string): ComponentParts => {\n  // example\n  // <script :setup=\"{ fname, lname }\">\n  //   const fullName = `${fname} ${lname}`\n  // </script>\n  //\n  // <div :attrs=\"{ fullName }\"></div>\n  // <div class=\"full-name\">\n  //  {{ fullName }}\n  // </div>\n  //\n  // <style>\n  // .full-name {\n  //  color: red;\n  // }\n  // </style>\n\n  // parsed as the content of a <template> so leading <script>/<style> tags\n  // aren't reparented into <head> by the HTML parser. All three pre-DOM string\n  // rewrites run here, and the order is load-bearing: camelCase names ->\n  // kebab-case first (before `:props.<n>` exists to be mangled and while a\n  // self-closing tag is still one occurrence), then `...expr` -> :props.<n>\n  // (which reads the raw camelCase before the parser can lowercase names),\n  // then self-closing tags\n  const prepared = expandSelfClosingTags(expandPropsSpread(expandNameCase(component)))\n  const parsedDOM = new DOMParser().parseFromString(`<template>${prepared}</template>`, \"text/html\")\n  const root = parsedDOM.querySelector(\"template\") as HTMLTemplateElement\n\n  // a top-level <template> declares another component of this file; everything\n  // else is this one's own\n  const own: Element[] = []\n  const declarations: HTMLTemplateElement[] = []\n  Array.from(root.content.children).forEach(el => {\n    if (el.tagName === \"TEMPLATE\") declarations.push(el as HTMLTemplateElement)\n    else own.push(el)\n  })\n\n  // the file's own component hashes the whole file: every component in it\n  // re-renders on any edit anyway (the file is the hot-reload unit), so a\n  // stamp that changes when a sibling is edited costs nothing, and scopeHash\n  // gets to keep hashing the source it was handed\n  const parts = componentPartsFrom(own, component)\n\n  // one map, shared by reference: it is filled below, after each definition\n  // has already been handed it, so every component of the file sees all the\n  // others *and itself* - which is what makes a recursive component possible\n  const siblings: Record<string, Component79> = {}\n  declarations.forEach(el => {\n    const name = el.getAttribute(\"name\")\n    // ignored rather than fatal, like every other malformed thing here: a bad\n    // save mid-typing must not take the page down, least of all under HMR\n    if (name === null) {\n      console.warn(\"jq79: a top-level <template> without a name declares nothing and was ignored\")\n      return\n    }\n    if (!COMPONENT_NAME_RE.test(name)) {\n      console.warn(\n        `jq79: <template name=\"${name}\"> was ignored - a component name has to be PascalCase, ` +\n        \"or no tag could ever reference it (only capitalized names resolve as components)\"\n      )\n      return\n    }\n    if (name in siblings) {\n      console.warn(`jq79: two <template name=\"${name}\"> in one file; the second was ignored`)\n      return\n    }\n    // its own source is its own scope: a named template is a shadow root\n    // inside a shadow root, so the file's scoped rules stop at its boundary\n    // and its own stop there too\n    siblings[name] = new Component79({ ...componentPartsFrom(Array.from(el.content.children), el.innerHTML), siblings, name })\n  })\n  if (Object.keys(siblings).length) parts.siblings = siblings\n\n  return parts\n}\n\n// the script/style/markup split of one component's top-level elements, with\n// <style scoped> resolved against the source those elements came from - the\n// whole file for its own component, a <template>'s contents for a named one,\n// so the two get different stamps and neither can style the other\nconst componentPartsFrom = (elements: Element[], hashSource: string): ComponentParts => {\n  const scripts: TagBlock[] = []\n  const styles: TagBlock[] = []\n  const template: TemplateNode[] = []\n\n  elements.forEach(el => {\n    const block: TagBlock = { attrs: elementAttrs(el), content: el.textContent ?? \"\" }\n\n    if (el.tagName === \"SCRIPT\") scripts.push(block)\n    else if (el.tagName === \"STYLE\") styles.push(block)\n    else template.push(elementToAST(el))\n  })\n\n  // <style lang=\"scss\"> is compiled by the jq79/vite plugin, so a `lang` still\n  // here means this component never went through it - it was fetched, loaded\n  // from a URL, or built from an inline string. The browser would drop the\n  // uncompiled source without a word, so say it out loud instead\n  styles.forEach(style => {\n    if (\"lang\" in style.attrs) {\n      console.warn(\n        `jq79: <style lang=\"${style.attrs.lang}\"> needs the jq79/vite plugin to compile it. ` +\n        \"This component didn't go through the bundler, so its styles were left uncompiled and the browser will ignore them.\"\n      )\n    }\n  })\n\n  // scoping is resolved once, here: the stamped template and the scoped CSS\n  // are what every instance of this definition renders and injects. An\n  // uncompiled `lang` block is left as it was written - rewriting selectors\n  // in something that isn't CSS yet would only garble what devtools shows\n  const isScoped = (style: TagBlock) => \"scoped\" in style.attrs && !(\"lang\" in style.attrs)\n  if (styles.some(isScoped)) {\n    const scope = scopeHash(hashSource)\n    stampScope(template, scope)\n    styles.forEach(style => {\n      if (isScoped(style)) style.scoped = scopeCss(style.content, scope)\n    })\n  }\n\n  return { template, scripts, styles }\n}\n\n// loads .html URLs as components, delegating anything else to native import().\n// Goes to fetchComponent rather than Component79.fetch because an import wants\n// the component, not the chainable handle the public entry point returns\nconst importResource = (url: string): Promise<any> =>\n  /\\.html?([?#]|$)/.test(url) ? fetchComponent(url) : import(url)\n\n// a relative specifier means \"next to the file that wrote it\", so it is\n// resolved against the component's own URL before importResource sees it -\n// neither of that function's two branches would otherwise land there. The\n// native import() inside it resolves against *this module* (dist/jq79.js), and\n// fetch() against the document; a component in a subdirectory gets a 404 from\n// the first and the page's directory from the second.\n//\n// What comes back is always a fully absolute URL, and that is the load-bearing\n// part rather than a detail of formatting. A *path* would be resolved by that\n// same native import() against the library module's ORIGIN - and the library\n// is the one file on the page most likely to come from somewhere else:\n//\n//   page   http://localhost:8024/craft/app.html\n//   jq79   https://jgermade.github.io/jq79/jq79.js\n//   \"/craft/services/x.js\"  ->  https://jgermade.github.io/craft/services/x.js\n//\n// which is a CORS error naming a host the app never mentioned. Only an\n// absolute URL means the same thing to both branches.\n//\n// For the same reason a *root-absolute* specifier is resolved too, not passed\n// through: `/x.js` means the page's root to whoever wrote it, and the page is\n// the only base under which the two branches agree. Bare specifiers (\"lodash\")\n// are the exception that stays untouched - they belong to the import map or\n// the bundler, and resolving one would quietly turn it into a path.\n//\n// The base is absolutized first, the way hotKey does and for the same reason:\n// the filename may itself be relative (\"./card.html\", from an import() in a\n// parent), and a relative URL cannot be a base\nconst RESOLVABLE_SPECIFIER_RE = /^(?:\\.\\.?\\/|\\/|[a-z][a-z0-9+.-]*:)/i\n\nconst resolveSpecifier = (spec: string, filename: string | undefined): string => {\n  if (!RESOLVABLE_SPECIFIER_RE.test(spec)) return spec\n  try {\n    return new URL(spec, new URL(filename ?? \"\", document.baseURI)).href\n  } catch {\n    return spec\n  }\n}\n\n// ---------------------------------------------------------------------------\n// naming scripts for devtools\n//\n// setup scripts are compiled with new Function (they need `with`, which is a\n// SyntaxError in a module), so no bundler source map can reach them: they show\n// up as an anonymous \"VM1234\" script, breakpoints don't survive a reload, and\n// stack traces name nothing. A //# sourceURL comment fixes all three - the\n// compiled script takes the component's name, so it is findable in the sources\n// tree, keeps its breakpoints, and appears by name in stack traces.\n//\n// The line numbers it reports are the compiled script's own, not the .html\n// file's: the engine wraps a Function body in a header (\"function anonymous(\n// args\\n) {\\n\") that shifts everything down, and no amount of padding can\n// shift code *up* to match a <script> sitting on line 1. Reporting the\n// component's real lines would need a source map, which the runtime doesn't\n// emit today\n// ---------------------------------------------------------------------------\n\n// where a script block came from: the component's filename, and its index\n// among the component's scripts (two scripts in one file need distinct names,\n// or devtools shows only one of them)\ntype ScriptLocation = { filename?: string; index?: number }\n\n// what running a script tells its caller: the promise it settles through, and\n// whether it already finished on this stack. `sync` is the fast path the render\n// gate is built on - see runSetupScript\ntype ScriptRun = { settled: Promise<unknown>; sync: boolean }\n\n// nothing to name an inline component's scripts after, so they stay anonymous\nconst sourceUrlComment = (filename: string | undefined, index: number): string =>\n  filename ? `\\n//# sourceURL=${filename}?jq79-script=${index}` : \"\"\n\n// what a <style> block injects into document.head: the scoped rewrite when it\n// has one, the source otherwise. A shadow root uses `content` directly instead\n// - scoping is what a shadow root already does, and doing both would break the\n// `:host` rules only shadow rendering can have (`:host[data-jq79=...]` matches\n// nothing: the host element is outside the template, so it carries no stamp)\nconst headStyle = (style: TagBlock): string => style.scoped ?? style.content\n\n// document.head styles are shared by content and refcounted, so N instances\n// of the same component (e.g. one per :each item) inject a single <style> tag\n// that goes away when the last instance is destroyed\nconst styleRegistry = new Map<string, { el: HTMLStyleElement; count: number }>()\n\nconst acquireStyle = (content: string) => {\n  let entry = styleRegistry.get(content)\n  if (!entry) {\n    const el = document.createElement(\"style\")\n    el.textContent = content\n    document.head.appendChild(el)\n    entry = { el, count: 0 }\n    styleRegistry.set(content, entry)\n  }\n  entry.count++\n}\n\nconst releaseStyle = (content: string) => {\n  const entry = styleRegistry.get(content)\n  if (entry && --entry.count <= 0) {\n    entry.el.remove()\n    styleRegistry.delete(content)\n  }\n}\n\n// scripts run inside `with (scriptScope)`, where scriptScope's `has` trap\n// claims ownership of every name that is neither a real global, an injected\n// library helper, nor one of the internal helpers. This makes `with` route ALL\n// other reads/writes through the reactive store - even bare assignments to\n// names never declared with let/const, which would otherwise leak onto\n// globalThis - while `console`, `Promise`, `fetch`, etc. still resolve\n// normally. get/set are deliberately not trapped: they default-forward to\n// `scope` (the reactive proxy), preserving tracking and notify.\n// The body is wrapped in an async IIFE so top-level `await` works: everything\n// up to the first await runs synchronously, and later assignments update the\n// DOM reactively when they happen.\n//\n// Returns whether the body ran to completion synchronously, plus the promise it\n// settles through. renderWith needs the *synchronous* answer - a script that\n// finished in this turn cannot hold anything up, so the template can render on\n// this stack exactly as it always has (see the render gate). Asking the promise\n// instead would defer every render by a microtask, including the overwhelmingly\n// common case of a script with no await in it at all.\n//\n// The flag is set on the code's last line, after the `with` block rather than\n// inside it, so the scope proxy never sees the name - and appended, so the\n// author's line numbers (which sourceUrlComment maps for devtools) don't shift\nconst runSetupScript = (code: string, scope: Record<string, any>, effect: (run: () => void) => void, instanceHelpers: Record<string, any> = {}, importer: (url: string) => Promise<any> = importResource, at: ScriptLocation = {}): ScriptRun => {\n  // instanceHelpers are per-component-instance additions (e.g. $emit, which\n  // is bound to this instance's DOM position)\n  const helpers = { ...SETUP_HELPERS, ...instanceHelpers }\n  const scriptScope = new Proxy(scope, {\n    has: (target, key) =>\n      key !== \"$__effect\" && key !== \"$__import\" && key !== \"$__state\" &&\n      (Reflect.has(target, key) || !(key in globalThis) && !(key in helpers)),\n  })\n  const state: { done?: boolean } = {}\n  const result: Promise<void> = new Function(\n    \"$scope\", \"$__effect\", \"$__import\", \"$__state\", ...Object.keys(helpers),\n    `return (async () => { with ($scope) { ${code} }\\n;$__state.done = true })()${sourceUrlComment(at.filename, at.index ?? 0)}`\n  )(scriptScope, effect, importer, state, ...Object.values(helpers))\n  result.catch(error => console.error(\"jq79: error in :setup script\", error))\n  trackScript(result)\n  return { settled: result, sync: state.done === true }\n}\n\n// puts a component's declared props on the store, before any script runs and\n// before the first render: the names, so the template can bind to them even\n// when the parent passes nothing, and the defaults, so it binds to something.\n//\n// A prop the parent *did* pass is already on the store (render() seeds it), so\n// a default only fills an `undefined` - which is also what JS destructuring\n// does with the same pattern, so both modes agree. It happens once, at setup:\n// re-applying a default later would need an effect that reads and writes the\n// same key, and that effect would wake itself forever.\n//\n// `null` props means the component declared no signature at all, which is not\n// the same as declaring an empty one: it keeps today's permissive behavior\nconst declareProps = (store: Record<string, any>, props: PropDecl[] | null) => {\n  props?.forEach(({ name, default: expr }) => {\n    if (store[name] !== undefined) return\n    store[name] = expr === undefined ? undefined : evalExpr(expr, store)\n  })\n}\n\n// a setup script's signature. A bare `<script :setup>` is a CLOSED signature -\n// the same as `<script :setup=\"{}\">`, declaring zero props and taking none -\n// because the difference between \"takes nothing\" and \"takes anything\" should\n// not be a pair of braces somebody didn't type. Permissive is still reachable,\n// it just has to be asked for: `<script :setup=\"_\">`, the same `_` convention\n// factory scripts already use, which parsePropsPattern reads as no signature.\n//\n// Only the empty *value* is closed. An absent attribute (a factory <script>\n// with no :setup at all) stays `null`, so its signature is still read from the\n// factory's first parameter\nconst setupSignature = (script: TagBlock): PropDecl[] | null => {\n  const pattern = script.attrs[\":setup\"]\n  if (pattern === undefined) return null\n  if (pattern.trim() === \"\") return []\n  const props = parsePropsPattern(pattern)\n  if (!props) warnUnreadableSignature(script, pattern)\n  return props\n}\n\n// script blocks already warned about, keyed by the block itself - parsed once\n// and shared by every instance of a definition, the same reason warnUndeclared\n// keys on the template node. It matters for a smaller reason here too:\n// setupSignature is called three times per render (both declared-name passes\n// and the script loop's declareProps), so even one mount would say it thrice\nconst signatureWarned = new WeakSet<TagBlock>()\n\n// a value that isn't a props pattern reads as \"declared no signature\", which is\n// the most permissive mode there is - so a typo doesn't fail, it quietly opts\n// the component out of the contract it was trying to write. That is now the\n// only accidental route left to permissive: a bare :setup is closed and `_` is\n// the opt-out you have to ask for, so the mode nothing lands in by accident is\n// still reachable by getting it wrong. Both of parsePropsPattern's nulls count\n// - not-an-object (\",{ a }\", \"props\") and unbalanced (\"{ a, b\") - and only `_`\n// is exempt, because intent is the sole thing separating it from the typos\nconst warnUnreadableSignature = (script: TagBlock, pattern: string) => {\n  if (pattern.trim() === \"_\" || signatureWarned.has(script)) return\n  signatureWarned.add(script)\n  console.warn(\n    `jq79: :setup=\"${pattern}\" is not a props pattern, so this component declares no ` +\n    `signature and takes whatever a parent passes - write the props it takes ` +\n    `(\"{ a, b }\"), a bare :setup for none, or \"_\" to stay open on purpose`\n  )\n}\n\n// every prop name a component's scripts declare, across both script modes.\n// Read before the store exists, because what a component declares decides\n// which of its file's sibling components it can still see: declaring a name\n// says it comes from the parent, so the file's own definition of that name is\n// deliberately not in this component's scope\nconst declaredPropNames = (scripts: TagBlock[]): Set<string> => {\n  const names = new Set<string>()\n  scripts.forEach(script => {\n    const declarations = parseFactoryProps(script.content) ?? setupSignature(script)\n    declarations?.forEach(({ name }) => names.add(name))\n  })\n  return names\n}\n\n// the same names, but null when NO script declared a signature at all - the\n// distinction declareProps already keeps, and the only one that can decide\n// whether to filter what a parent passes. `<script :setup>` and\n// `<script :setup=\"{}\">` are both closed signatures that take nothing (see\n// setupSignature); `<script :setup=\"_\">` is the permissive one\nconst declaredPropSet = (scripts: TagBlock[]): Set<string> | null => {\n  let names: Set<string> | null = null\n  scripts.forEach(script => {\n    const declarations = parseFactoryProps(script.content) ?? setupSignature(script)\n    if (!declarations) return\n    const into = (names ??= new Set())\n    declarations.forEach(({ name }) => into.add(name))\n  })\n  return names\n}\n\n// drops the props a component didn't declare, so an undeclared name is simply\n// absent from its store rather than quietly present: `{{ label }}` renders\n// empty and `{{ user.name }}` throws on the member access, both at the usage\n// site that got the name wrong. A null signature keeps everything - see\n// declaredPropSet. Silent by design: the main source of extra keys is a\n// `:props` spread of an object wider than the component (`...sdk`), where\n// taking only the declared few is the point, not a mistake to report\nconst pickDeclared = (props: Record<string, any>, declared: Set<string> | null): Record<string, any> => {\n  if (declared === null) return props\n  const out: Record<string, any> = {}\n  Object.keys(props).forEach(key => { if (declared.has(key)) out[key] = props[key] })\n  return out\n}\n\n// names already reported by warnUndeclared, keyed by the template node - which\n// is the usage site itself, built once and shared by every instance it ever\n// renders. So a :each over 200 rows says it once, not once per row, and a\n// definition swap doesn't repeat what the last one already said\nconst undeclaredWarned = new WeakMap<TemplateNode, Set<string>>()\n\n// a parameter the child's signature doesn't declare is dropped by pickDeclared\n// and never reaches its store - `{{ bar }}` renders empty at the other end of\n// the file. Written parameters only: this is handed the named ones (`:bar`,\n// and the prop each :model binds), never a `:props` spread's keys, because a\n// spread of an object wider than the component is the documented, intended use\n// and taking only the declared few is its point - see pickDeclared. A\n// component with no signature at all declares nothing to compare against\nconst warnUndeclared = (node: TemplateNode, name: string, written: string[], declared: Set<string> | null) => {\n  if (declared === null) return\n  const said = undeclaredWarned.get(node) ?? new Set<string>()\n  undeclaredWarned.set(node, said)\n  written.forEach(prop => {\n    if (declared.has(prop) || said.has(prop)) return\n    said.add(prop)\n    console.warn(`jq79: :${prop} is not declared by <${name}> - add it to the :setup signature, or drop it`)\n  })\n}\n\n// the sibling components this one resolves by name, or null when there are\n// none left to resolve. They go on the store's *prototype* rather than in it:\n// the component-key scan walks the chain, so <Row> resolves; they stay out of\n// the data, so Object.keys, snapshots and spreads never see them; and an own\n// key shadows a prototype one, so a prop the parent did pass wins for free\nconst siblingsInScope = (\n  siblings: Record<string, Component79> | undefined,\n  declared: Set<string>\n): Record<string, Component79> | null => {\n  if (!siblings) return null\n  // null-prototype, for the same reason storeApi is: `key in scope` must not\n  // start answering true for toString, constructor and the rest\n  const inScope: Record<string, Component79> = Object.create(null)\n  let any = false\n  Object.entries(siblings).forEach(([name, component]) => {\n    if (declared.has(name)) return\n    inScope[name] = component\n    any = true\n  })\n  return any ? inScope : null\n}\n\n// names a component declared as props and the parent passed nothing for. Such\n// a name can never become a component later - there is no binding on the tag\n// to update it - so a <Tag> reading one is a wiring mistake that can be named\n// on sight, unlike the `undefined` of an import still in flight. Symbol-keyed\n// and non-enumerable: it rides the scope chain (so an :each item scope finds\n// it too) without ever showing up as data\nconst UNFILLED_PROPS = Symbol(\"jq79.unfilledProps\")\n\n// how many of this render generation's scripts have yet to settle, as a live\n// box rather than a snapshot. Rides the scope chain like UNFILLED_PROPS, and\n// for one reader: a <Tag> naming no component in scope is only a mistake once\n// nothing is left that could still supply the name.\n//\n// The count is not the render gate. A script that called $mounted() released\n// the template and is still running - that is the whole point of the call - so\n// at paint time this can be non-zero, and a name arriving from a factory that\n// awaited $mounted() is exactly the case the count keeps quiet. Read live, so\n// an :if that opens after everything settled is judged against the scripts as\n// they are then, not as they were at the first paint\nconst PENDING_SCRIPTS = Symbol(\"jq79.pendingScripts\")\n\ntype PendingScripts = { count: number }\n\n// default-import interop for factory scripts: real modules expose .default,\n// while importing an .html component resolves to the Component79 itself\nconst interopDefault = (mod: any) => (mod && mod.default !== undefined ? mod.default : mod)\n\n// runs a factory script: the (rewritten) module body executes in plain\n// lexical strict-mode scope - no `with`, no implicit reactivity - with the\n// library helpers as parameters, then the default export is called with the\n// instance context and a returned object is merged into the store. A fully\n// synchronous body invokes the factory before the first render, matching\n// setup-script timing; bodies with top-level await (static imports included)\n// resolve later and the template updates reactively\nconst runFactoryScript = (code: string, scope: Record<string, any>, effect: (run: () => void) => void, instanceHelpers: Record<string, any> = {}, importer: (url: string) => Promise<any> = importResource, at: ScriptLocation = {}): ScriptRun => {\n  const helpers = { ...SETUP_HELPERS, ...instanceHelpers }\n  const $__exports: { default?: (props: Record<string, any>, ctx: Record<string, any>) => any; done?: boolean } = {}\n  const result: Promise<void> = new Function(\n    \"$__exports\", \"$__default\", \"$__import\", ...Object.keys(helpers),\n    `return (async () => { \"use strict\";\\n${code}\\n;$__exports.done = true })()${sourceUrlComment(at.filename, at.index ?? 0)}`\n  )($__exports, interopDefault, importer, ...Object.values(helpers))\n\n  const logError = (error: any) => console.error(\"jq79: error in factory script\", error)\n  let invoked = false\n  // what invoke() is still waiting on, memoized: it is called from both paths\n  // below and does its work once, but the *second* caller is the one whose\n  // promise is tracked - without this it would see `undefined` and count the\n  // script as settled while an async factory's bindings are still on the way\n  let merging: Promise<void> | undefined\n  const invoke = (): Promise<void> | undefined => {\n    if (invoked) return merging\n    invoked = true\n    const factory = $__exports.default\n    if (typeof factory !== \"function\") return undefined\n    const merge = (bindings: any) => {\n      if (bindings && typeof bindings === \"object\") Object.assign(scope, bindings)\n    }\n    // the sync path is invoked straight from render(), so a throwing factory\n    // must be caught here too - not just by the `result` rejection handler\n    try {\n      // props first, ctx second. Both are the store: the pattern destructures\n      // the props it declared (copying, as destructuring does - $props is the\n      // live view for a primitive the parent reassigns later)\n      const returned = factory(scope, { $data: scope, $props: scope, $effect: effect, ...instanceHelpers })\n      if (returned instanceof Promise) merging = returned.then(merge).catch(logError)\n      else merge(returned)\n    } catch (error) {\n      logError(error)\n    }\n    return merging\n  }\n\n  // tracked through the merge, not just the module body: a factory's names\n  // reach the store in `merge`, and a template expression that reads one before\n  // then is not an authoring mistake (see reportExprError)\n  const settled = result.then(invoke, logError)\n  trackScript(settled)\n  if ($__exports.done) invoke() // fully-sync body: factory runs before first render\n  // sync only if the bindings are already on the store: a factory whose body\n  // finished but whose *factory* returned a promise (an async factory, or one\n  // that awaits $mounted()) still has names on the way, and the render gate\n  // must treat it as pending rather than race its merge\n  return { settled, sync: $__exports.done === true && merging === undefined }\n}\n\n// ---------------------------------------------------------------------------\n// hot reload\n//\n// Both delivery paths want the same thing when a .html file changes: reparse\n// it, and re-render every live instance of it in place, keeping its data. The\n// swap lives in the runtime (hotReplace, below) so jq79/dev and the Vite\n// plugin share one implementation instead of two - and so it can reach the\n// private fields it needs (the markers, the holding fragment) rather than\n// poking at them from outside, which is what the plugin used to do.\n//\n// Finding the instances is the part only the runtime can do: a component\n// fetched at runtime is reachable from nothing but the DOM it rendered. So\n// instances register themselves - but only once a page opts in, before the\n// runtime loads. Nothing here costs a bundled app anything: with the registry\n// off, an instance is not tracked at all.\n// ---------------------------------------------------------------------------\n\nconst HOT_FLAG = \"__JQ79_HMR_ENABLED__\"\nconst HOT_RUNTIME = \"__JQ79_HMR__\"\n\n// live instances by filename. WeakRef because a destroyed component that the\n// page has dropped must stay collectable: `:each` churns through clones\nlet hotRegistry: Map<string, Set<WeakRef<Component79>>> | null = null\n\nconst hotRegister = (instance: Component79) => {\n  if (!hotRegistry || !instance.filename) return\n  let refs = hotRegistry.get(instance.filename)\n  if (!refs) hotRegistry.set(instance.filename, (refs = new Set()))\n  refs.add(new WeakRef(instance))\n}\n\n// the same file reaches the runtime under different names - \"./card.html\" from\n// an import() in a setup script, \"/cards/card.html\" from a fetch, \"cards/card.\n// html\" from the dev server that watched it - and they all have to land on one\n// key. Resolving against the page is what settles them\nconst hotKey = (filename: string): string => {\n  try {\n    return new URL(filename, document.baseURI).pathname\n  } catch {\n    return filename\n  }\n}\n\n// swaps the file's new source into every instance that came from `filename`,\n// and returns how many of them were *on the page* and so re-rendered. Zero\n// means the change is not visible anywhere - the file is a page rather than a\n// component, or nothing has mounted it yet - and the caller (a dev server)\n// should fall back to reloading. Definitions and instances that have been\n// destroyed but not yet collected are patched all the same; they just don't\n// count, because nothing on screen changed for them\nexport const hotUpdate = (filename: string, src: string): number => {\n  if (!hotRegistry) return 0\n\n  const key = hotKey(filename)\n  // parsed once and shared by every instance - which is already what a\n  // definition and the clones :component makes from it do\n  const parts = parseComponentString(src)\n  // the file is the hot-reload unit, so one reparse serves every component it\n  // declares: an instance is handed the parts of the component it *is*, by\n  // name. A name that is no longer in the file (a <template> renamed or\n  // deleted) has no parts to be given, and only a reload can fix the page\n  let orphaned = false\n  const partsFor = (instance: Component79): ComponentParts | null =>\n    instance.name === undefined ? parts : parts.siblings?.[instance.name] ?? null\n\n  let rerendered = 0\n  for (const [name, refs] of hotRegistry) {\n    if (hotKey(name) !== key) continue\n    for (const ref of refs) {\n      const instance = ref.deref()\n      if (!instance) {\n        refs.delete(ref) // collected since the last update\n        continue\n      }\n      const next = partsFor(instance)\n      if (!next) {\n        orphaned = true\n        continue\n      }\n      if (instance.hotReplace(next)) rerendered++\n    }\n    if (!refs.size) hotRegistry.delete(name)\n  }\n  return orphaned ? 0 : rerendered\n}\n\n// starts tracking instances, so hotUpdate can find them. jq79/dev's client\n// calls this through the global handshake at the foot of this file; it is\n// exported so a bundled app - or a test - can opt in directly\nexport const enableHotReload = (): void => {\n  hotRegistry ??= new Map()\n  ;(globalThis as any)[HOT_RUNTIME] = { update: hotUpdate }\n}\n\ntype EmitListener = (event: CustomEvent, payload: any) => void\n\n// how long a first render may sit behind its scripts before the console says so\nconst STUCK_RENDER_DELAY = 3000\n\n// a script that neither returns nor calls $mounted() holds the template\n// forever, and the failure looks like nothing at all: no error, no markup, a\n// component indistinguishable from one nobody mounted. So the wait is loud\n// after a few seconds - and it keeps waiting, because rendering on a timer\n// would make the moment of the first render depend on the machine it runs on.\n//\n// Armed only on the deferred path, so a page of synchronous components creates\n// no timers at all\nconst warnIfStuck = (component: Component79, gates: Promise<void>[]) => {\n  const timer = setTimeout(() => {\n    console.warn(\n      `jq79: ${component.name ? `<${component.name}>` : \"a component\"}${component.filename ? ` (${component.filename})` : \"\"} ` +\n      `has been waiting ${STUCK_RENDER_DELAY / 1000}s for a :setup script and has rendered nothing. ` +\n      \"The template waits until every script returns or calls $mounted() - add an \" +\n      \"await $mounted() above the slow part to render first and fill in after.\"\n    )\n  }, STUCK_RENDER_DELAY)\n  // unref where it exists (node/vitest): a pending timer must not be what keeps\n  // a process alive. Browsers have no such notion and no such need\n  ;(timer as any)?.unref?.()\n  Promise.all(gates).then(() => clearTimeout(timer))\n}\n\nconst fetchComponent = async (url: string): Promise<Component79> => {\n  const response = await fetch(url)\n  if (!response.ok) throw new Error(`failed to fetch component from ${url}: ${response.status}`)\n  // the URL names the component's scripts in devtools, and is where the\n  // browser will look for the source when a breakpoint lands in one\n  return new Component79(await response.text(), { filename: url })\n}\n\n// a parsed single-file component. Typical lifecycle:\n//\n//   const jq79 = new Component79(src)   // or await Component79.fetch(url)\n//   jq79.on(\"submit\", (e, payload) => {}) // hear this instance's $emit events\n//   jq79.mount(\"#app\", { user })        // render (reactive DOM, scripts, styles) + attach\n//   ...                                 // (mountShadow mounts into a shadow root)\n//   jq79.detach()                       // detach, keeping state - mount() re-attaches\n//      .destroy()                      // dispose effects and remove styles\nexport class Component79 {\n  // the version of jq79 this class came from, so a page can tell which build it\n  // loaded (a CDN <script> pins nothing on its own)\n  static readonly version: string = VERSION\n\n  template: TemplateNode[]\n  scripts: TagBlock[]\n  styles: TagBlock[]\n  // pre-resolved modules for setup-script `import(...)` calls (see\n  // ComponentParts.modules); checked before falling back to fetch/import\n  modules?: Record<string, any>\n  // the component's origin, used to name its scripts in devtools\n  filename?: string\n  // the other components declared in the same file, by name (see\n  // ComponentParts.siblings). They are also this definition's own properties,\n  // so `const { Row } = await Component79.fetch(url)` reaches them\n  siblings?: Record<string, Component79>\n  // this component's name inside its file, for the components a <template>\n  // declared; the file's own component has none - it is the default, and a\n  // default is named by whoever imports it\n  name?: string\n  // the content the usage site handed this instance, by slot name (see the\n  // slots section). Not part of a definition - it belongs to the tag that\n  // wrote it - so renderNestedComponent sets it on the instance it creates,\n  // and every render reads it from here: a hot reload re-renders from a data\n  // snapshot, which a symbol on the store would not survive\n  slots?: SlotMap\n  // the writeback half of :model, same story: the function that assigns into\n  // the parent, set by renderNestedComponent before the first render and\n  // called by this instance's $updateModel. Kept outside the render generation\n  // so it survives re-render and hot reload. Absent means no :model on the tag\n  // (or no tag at all - a root mount), which makes every $updateModel a no-op.\n  // Internal: set by the usage site, not part of the public API\n  modelWriteback?: (name: string | undefined, value: any) => boolean\n\n  data: ReactiveDeepData<Record<string, any>> | null = null\n\n  private fx: EffectScope | null = null\n  // holds the rendered nodes while detached; anchors keep this fragment as\n  // their parentNode, so effects keep the (detached) DOM up to date and a\n  // later mount() shows current state\n  private content: DocumentFragment | null = null\n  // markers bracketing the component's output so detach() can collect nodes\n  // that :if/:each inserted next to the anchors after mounting\n  private startMarker: Comment | null = null\n  private endMarker: Comment | null = null\n  // shadow rendering keeps per-instance <style> elements; head rendering goes\n  // through the shared refcounted styleRegistry instead\n  private styleEls: HTMLStyleElement[] = []\n  private ownsSharedStyles = false\n  private useShadow = false\n  private mountRoot: Element | ShadowRoot | DocumentFragment | null = null\n  // settles the $mounted() promise handed to this render generation's scripts\n  private resolveMounted: (() => void) | null = null\n  // whether this generation's template has been built. A render held back by a\n  // script (see the gate in renderWith) has markers but no nodes, and $mounted()\n  // must not resolve on attach alone - a script awaiting it would wake to an\n  // empty component and find nothing to query\n  private renderDone = false\n  // instance-level listeners for $emit events, registered with on(). Kept\n  // outside the render generation so they survive re-render and destroy()\n  private emitListeners = new Map<string, Set<EmitListener>>()\n\n  constructor(src: string | ComponentParts, options: { modules?: Record<string, any>; filename?: string } = {}) {\n    const parts = typeof src === \"string\" ? parseComponentString(src) : src\n    this.template = parts.template\n    this.scripts = parts.scripts\n    this.styles = parts.styles\n    this.modules = options.modules ?? (typeof src === \"string\" ? undefined : src.modules)\n    this.filename = options.filename ?? (typeof src === \"string\" ? undefined : src.filename)\n    this.siblings = parts.siblings\n    this.name = parts.name\n    this.adoptSiblings()\n    hotRegister(this) // a no-op unless the page enabled hot reload\n  }\n\n  // the parser builds a file's sibling definitions before anyone has told it\n  // where the file came from, so whoever holds the parse hands its origin down\n  // - and keeps doing it after a hot reload, which parses the file afresh.\n  // Without it a reloaded child would have no filename, and an instance with\n  // no filename is not tracked: the next edit would never reach it\n  private adoptSiblings() {\n    if (!this.siblings) return\n    Object.entries(this.siblings).forEach(([name, sibling]) => {\n      sibling.filename ??= this.filename\n      sibling.modules ??= this.modules\n      // the file's own component also *is* the file: its named components hang\n      // off it as properties, which is what `const { Row } = …` reads (and\n      // what the bundler re-exports by name)\n      if (!this.name) (this as any)[name] = sibling\n    })\n  }\n\n  // swaps this component's parsed parts for `src`'s and, if it is on the page,\n  // re-renders it where it stands - seeded with a snapshot of its data, so\n  // props and store values survive (the setup script runs again, so whatever it\n  // initializes is reset). Returns whether it re-rendered: an instance that was\n  // never rendered is a *definition*, and patching its parts is all there is to\n  // do - the clones :component made from it are instances in their own right,\n  // registered under the same filename, and re-render themselves.\n  //\n  // Dev-only, and not part of the public API: jq79/dev and the Vite plugin call\n  // it when a file changes. It re-attaches against the markers rather than\n  // mountRoot on purpose - a nested clone is mounted into a fragment that is\n  // then emptied into the page, so its mountRoot is a stale, detached fragment\n  // while its markers sit where its DOM actually is\n  hotReplace(src: string | ComponentParts): boolean {\n    const parts = typeof src === \"string\" ? parseComponentString(src) : src\n    // the source just changed, so what was already said about it no longer\n    // applies: without this the author fixes the typo, saves, and the next typo\n    // in the same expression is deduped away against the old one. `compiled`\n    // needs no such reset - it is keyed by expression text, so edited source is\n    // a different key\n    reportedExprErrors.clear()\n    pendingReports.clear()\n    reportedFailedExprs.clear()\n    const marker = this.startMarker\n    const rendered = !!(marker && this.content)\n\n    // where its output sits now, if it is on the page. A rendered-but-detached\n    // instance (markers in the holding fragment) re-renders detached, and a\n    // later mount() attaches the new output - like any update it missed away\n    const live = rendered && marker!.isConnected\n    const parent = live ? (marker!.parentNode as Element | ShadowRoot | DocumentFragment) : null\n    const before = live ? this.endMarker!.nextSibling : null\n    const data = { ...this.data }\n    const shadow = this.useShadow\n\n    // destroy() releases the styles it acquired, so it has to run while\n    // this.styles is still the *old* set - swapping the parts first would leak\n    // the old stylesheet into the head and release a new one nobody holds\n    if (rendered) this.destroy()\n\n    this.template = parts.template\n    this.scripts = parts.scripts\n    this.styles = parts.styles\n    // the file's other components as they are now: the next render resolves\n    // <Row> against these, so a parent picks up an edited child even when the\n    // child's own instances are patched separately\n    this.siblings = parts.siblings\n    this.adoptSiblings()\n    if (!rendered) return false // a definition: its clones re-render themselves\n\n    this.renderWith(data, shadow)\n    if (!parent) return false\n\n    // shadow styles live inline, right before the DOM they style (attach()\n    // appends them ahead of the content), so they go back the same way\n    if (shadow) this.styleEls.forEach(el => parent.insertBefore(el, before))\n    parent.insertBefore(this.content!, before)\n    this.mountRoot = parent\n    this.settleMounted()\n    return true\n  }\n\n  // downloads and parses a component, handing back a PendingComponent79: a\n  // handle that can be mounted right away, and that awaits to this component -\n  // so both of these are the whole program\n  //\n  //   Component79.fetch(\"./app.html\").mount(\"main\")\n  //   const app = await Component79.fetch(\"./app.html\")\n  static fetch(url: string): PendingComponent79 {\n    if (Array.isArray(url)) throw new TypeError(\"Component79.fetch takes one URL; use fetchAll for an array\")\n    return new PendingComponent79(fetchComponent(url))\n  }\n\n  // fetches them all at once and resolves to the components in the same order,\n  // so one await destructures them - and, like Promise.all, the first failure\n  // rejects the whole thing. A plain promise, not a handle: mounting a *list*\n  // of components has no single meaning\n  static fetchAll(urls: string[]): Promise<Component79[]> {\n    return Promise.all(urls.map(fetchComponent))\n  }\n\n  // subscribes to this instance's $emit events, on top of the DOM CustomEvent\n  // dispatch - so it hears emits even while the component is detached (where\n  // the event has no ancestors to bubble to). Chainable; can be called before\n  // render()\n  on(eventName: string, listener: EmitListener): this {\n    if (!this.emitListeners.has(eventName)) this.emitListeners.set(eventName, new Set())\n    this.emitListeners.get(eventName)!.add(listener)\n    return this\n  }\n\n  off(eventName: string, listener: EmitListener): this {\n    this.emitListeners.get(eventName)?.delete(listener)\n    return this\n  }\n\n  render(data: Record<string, any> = {}): this {\n    return this.renderWith(data, false)\n  }\n\n  // like render(), but styles are injected into a shadow root attached to the\n  // mount target instead of document.head, so they don't leak globally\n  renderShadow(data: Record<string, any> = {}): this {\n    return this.renderWith(data, true)\n  }\n\n  private renderWith(data: Record<string, any>, shadow: boolean): this {\n    this.destroy()\n\n    // what this component can see of its file's other components, and which of\n    // its declared props arrived empty - both decided by the signature, before\n    // the store exists (see siblingsInScope / UNFILLED_PROPS)\n    const declared = declaredPropNames(this.scripts)\n    const siblingScope = siblingsInScope(this.siblings, declared)\n    const raw: Record<string, any> = siblingScope\n      ? Object.assign(Object.create(siblingScope), data)\n      : { ...data }\n    const unfilled = new Set([...declared].filter(name => !(name in data)))\n    if (unfilled.size) Object.defineProperty(raw, UNFILLED_PROPS, { value: unfilled })\n    // the slot content, for the <slot>s the template renders, and the static\n    // map of which names were filled, for the component to ask about\n    // (`<footer :if=\"$slots.footer\">`). Filled at the usage site, so it can\n    // only change when the tag itself re-renders - which builds a new instance\n    if (this.slots) Object.defineProperty(raw, SLOTS, { value: this.slots })\n    // in place before the store wraps it, because the scripts that increment it\n    // run against the store and the template reads it back through the same\n    // scope chain. Read back out of `raw` where it is needed rather than kept\n    // in a local: this frame is on the stack for the whole of the subtree it\n    // renders, so a component nested inside itself pays for it once per level -\n    // and the depth guard at MAX_NESTING_DEPTH only beats a RangeError while\n    // this function stays small (see the note in docs/development.md)\n    Object.defineProperty(raw, PENDING_SCRIPTS, { value: { count: 0 } as PendingScripts })\n\n    const store = $reactive(raw)\n    const fx = createEffectScope(store)\n    this.data = store\n    this.fx = fx\n    this.useShadow = shadow\n\n    this.startMarker = document.createComment(\"jq79\")\n    this.endMarker = document.createComment(\"/jq79\")\n\n    // $emit dispatches a bubbling CustomEvent from this instance's start\n    // marker, so once mounted it travels up the real DOM and parents can\n    // listen on any ancestor (or with @event-name on a wrapping element).\n    // Captures the marker rather than `this` so a later re-render's scripts\n    // can't dispatch from the wrong generation - the same guard keeps stale\n    // generations from reaching the instance's on() listeners.\n    // The on() channel runs *first* (it's where @event on a component tag is\n    // wired - see wireTagEvent) so its listeners can shape the DOM dispatch:\n    // stopPropagation() there keeps the event off the DOM entirely, and the\n    // event is cancelable so preventDefault() - from either channel - flips\n    // the return to false, telling the emitting child \"the parent vetoed\"\n    const marker = this.startMarker\n    // model:update used to be the writeback's event name; it is a direct call\n    // now ($updateModel), so an emit under that name reaches nothing. Said\n    // once per generation rather than per keystroke, and said at all because\n    // the alternative is a child whose edits silently stop arriving\n    let warnedModelUpdate = false\n    const $emit = (eventName: string, payload?: any): boolean => {\n      if (eventName === \"model:update\" && !warnedModelUpdate) {\n        warnedModelUpdate = true\n        console.warn(\"jq79: $emit('model:update', …) no longer feeds :model - call $updateModel(value) or $updateModel(name, value) instead\")\n      }\n      const event = new CustomEvent(eventName, { detail: payload, bubbles: true, composed: true, cancelable: true })\n      if (marker === this.startMarker) {\n        this.emitListeners.get(eventName)?.forEach(listener => listener(event, payload))\n      }\n      // cancelBubble is the spec's legacy name, but it's the only *readable*\n      // accessor for the stop-propagation flag - hence the deprecation hint\n      if (!event.cancelBubble) marker.dispatchEvent(event)\n      return !event.defaultPrevented\n    }\n\n    // `await $mounted()` suspends a setup script until the component is\n    // rendered *and* attached, so code below it can querySelector its own DOM.\n    // If this instance is never mounted, the promise stays pending and the\n    // script's tail never runs.\n    //\n    // Calling it is also how a script releases the first render - see the gate\n    // below - so the two halves of the contract are one call: \"put me on the\n    // page, and don't wait for the rest of me\"\n    let resolveMounted!: () => void\n    const mounted = new Promise<void>(resolve => { resolveMounted = resolve })\n    this.resolveMounted = resolveMounted\n    this.renderDone = false\n\n    // $self / $$self mirror $ / $$ but only search this instance's own\n    // output: the sibling nodes between its markers. They work detached too\n    // (the holding fragment keeps markers and rendered nodes as siblings),\n    // though the template renders after the scripts run, so they only find\n    // something from post-await code or callbacks\n    const endMarker = this.endMarker\n    const $$self = (selector: string): Element[] => {\n      const found: Element[] = []\n      for (let node: Node | null = marker.nextSibling; node && node !== endMarker; node = node.nextSibling) {\n        if (node instanceof Element) {\n          if (node.matches(selector)) found.push(node)\n          found.push(...Array.from(node.querySelectorAll(selector)))\n        }\n      }\n      return found\n    }\n    const $self = (selector: string): Element | null => $$self(selector)[0] ?? null\n\n    // import() calls whose specifier was pre-resolved by a bundler (the\n    // modules map) get the bundled module; everything else falls back to the\n    // runtime importResource (fetch for .html, native import otherwise),\n    // relative to this component's file. The map is keyed by the literal\n    // specifier the script wrote, so it is consulted *before* resolution -\n    // what the bundler hoisted and what the source says are the same string\n    const modules = this.modules\n    const $import = (url: string): Promise<any> =>\n      modules && url in modules\n        ? Promise.resolve(modules[url])\n        : importResource(resolveSpecifier(url, this.filename))\n\n    // the writeback half of :model, from the child's side: one argument is the\n    // value for the default model (the bare :model), two are a name and a\n    // value. Arity is what tells them apart, so the value is never inspected -\n    // an object with `name`/`value` keys is just a value, which is exactly\n    // what a payload-shaped contract could not promise. Returns whether a\n    // bound model took it; no :model at the usage site is a silent no-op,\n    // since a child may be designed to work bound or unbound\n    const $updateModel = (...args: [value?: any] | [name: string, value: any]): boolean => {\n      const [name, value] = args.length > 1 ? args as [string, any] : [undefined, args[0]]\n      // the same stale-generation guard $emit has: destroy() nulls the marker,\n      // so a closure the old child leaked (a timer, a registered callback)\n      // cannot keep writing a parent that replaced it\n      if (marker !== this.startMarker) return false\n      return this.modelWriteback?.(name, value) ?? false\n    }\n\n    // the names a component answers on top of its store: $emit, so an inline\n    // handler can emit without routing through a setup function\n    // (@input=\"$emit('update', $event.target.value)\"), $updateModel, the\n    // writeback a :model binding listens for, and $slots, the static map of\n    // the names the usage site filled, so a wrapper can be dropped when\n    // nothing filled it (<footer :if=\"$slots.footer\">). All reach the\n    // template (through templateScope, below) and both script modes (as\n    // instance helpers), and a same-named store key shadows any of them.\n    // Null-prototype, for the same reason storeApi is: `key in injected` must\n    // not start answering true for toString, constructor and the rest\n    const injected: Record<string, any> = Object.assign(Object.create(null), {\n      $emit,\n      $updateModel,\n      $slots: Object.fromEntries(Object.keys(this.slots ?? {}).map(name => [name, true])),\n    })\n\n    // scripts run before the template renders so `$:` values are initialized;\n    // a `:mounted` script defers entirely until mount() instead. A top-level\n    // `export default` switches the script to factory mode (plain lexical JS)\n    // a `:mounted` script is deferred by prepending the await on the code's own\n    // first line, so deferring doesn't shift the lines devtools reports for it\n    const defer = (code: string) => `await $mounted();${code}`\n\n    // what the first render is still waiting for. A script holds the template\n    // back until it returns or calls $mounted() - whichever comes first - so\n    // `let rows = await fetch(...)` renders once, with rows, instead of\n    // rendering empty and filling in. `:mounted` is not a special case here: it\n    // *is* a script that yields on line 0, which is what `defer` above writes.\n    //\n    // One gate per script, not one per instance: a script yielding must not\n    // release the render on behalf of a sibling script that is still fetching\n    const gates: Promise<void>[] = []\n    let allSync = true\n\n    this.scripts.forEach((script, index) => {\n      let resolveGate!: () => void\n      gates.push(new Promise<void>(resolve => { resolveGate = resolve }))\n      // whether this gate is already open on *this* stack, which is not the\n      // same as the script having finished: a script that yields immediately\n      // (`await $mounted()` on its first line, which is what `:mounted`\n      // compiles to) never finishes synchronously but holds nothing up either.\n      // Reading the promise instead would push every such render a microtask\n      // later, for no one's benefit\n      let open = false\n      const release = () => { open = true; resolveGate() }\n      // this script's own view of $mounted: the call releases its gate, the\n      // promise it returns is the instance's (one mount, one resolution)\n      const $mounted = () => { release(); return mounted }\n      // the file's other components are passed as parameters of the compiled\n      // script, not just left on the store's prototype: a factory script runs\n      // as plain lexical JS with no `with`, so a bare `Row` in one would\n      // resolve to nothing at all. In setup mode this composes with `with` -\n      // scriptScope's `has` declines any name that is a helper, so the\n      // parameter is what the name resolves to\n      const instanceHelpers = { $mounted, $self, $$self, ...injected, ...siblingScope }\n      const at: ScriptLocation = { filename: this.filename, index }\n      const deferred = \":mounted\" in script.attrs\n      const factoryCode = transformFactoryScript(script.content)\n      const run = ((): ScriptRun => {\n        if (factoryCode !== null) {\n          // a factory publishes its names by returning them, so one that yields\n          // before it returns renders against a store where none of them exist.\n          // In factory mode `:mounted` yields on line 0, which means *always* -\n          // and unlike a setup script there is no way to put the useful half\n          // above the yield. Awaiting $mounted() inside the factory does what\n          // the author meant, and is what the message points at\n          if (deferred) {\n            console.warn(\n              \"jq79: :mounted on a factory script renders the template before the factory has returned, \" +\n              \"so none of its bindings exist yet - await $mounted() inside the factory instead.\"\n            )\n          }\n          declareProps(store, parseFactoryProps(script.content))\n          const body = deferred ? defer(factoryCode) : factoryCode\n          return runFactoryScript(body, store, fx.effect, instanceHelpers, $import, at)\n        }\n        const { vars, code } = transformSetupScript(script.content)\n        declareProps(store, setupSignature(script))\n        // pre-declare script vars on the store so `with` resolves assignments\n        // to them (and reads of them) through the reactive proxy\n        vars.forEach(name => { if (!(name in store)) (store as any)[name] = undefined })\n        const body = deferred ? defer(code) : code\n        return runSetupScript(body, store, fx.effect, instanceHelpers, $import, at)\n      })()\n      // a script that threw has nothing left to contribute, so its rejection\n      // releases the gate exactly as completion does - the error is already\n      // reported by the runner, and holding the template hostage to it would\n      // turn one broken script into a blank component. It also stops counting\n      // as a source of names, for that same reason.\n      //\n      // A script that finished on this stack is counted at zero rather than\n      // incremented and decremented a microtask later: its names are on the\n      // store already, and the promise it settles through does not resolve\n      // until after the synchronous paint - which is every paint, for the\n      // components that have no await in them at all\n      if (run.sync) run.settled.then(release, release)\n      else {\n        const pending: PendingScripts = (raw as any)[PENDING_SCRIPTS]\n        pending.count++\n        const settle = () => { pending.count--; release() }\n        run.settled.then(settle, settle)\n      }\n      if (!run.sync && !open) allSync = false\n    })\n\n    const content = document.createDocumentFragment()\n    // the injected names, served by has/get only - never as own keys - so\n    // Object.keys, snapshot spreads and the component-key scan don't see them,\n    // and every read still forwards through the reactive store, keeping\n    // dependency tracking intact\n    const templateScope = new Proxy(store as Record<string, any>, {\n      has: (target, key) => (typeof key === \"string\" && key in injected) || Reflect.has(target, key),\n      get: (target, key, receiver) =>\n        typeof key === \"string\" && key in injected && !Reflect.has(target, key)\n          ? injected[key]\n          : Reflect.get(target, key, receiver),\n    })\n    // the markers go in either way, so render() returns something mountable\n    // whether or not the template has been built yet: they are what detach()\n    // collects between and what the deferred pass inserts before, exactly as\n    // :if/:each anchors already work. That is what keeps render() and mount()\n    // synchronous while the first render itself is allowed to wait\n    content.append(this.startMarker, this.endMarker)\n    this.content = content\n    if (allSync) {\n      // nothing is pending, so the template is built on this stack - the\n      // ordinary case, and byte-for-byte the timing render() has always had.\n      //\n      // Written out rather than routed through the closure below on purpose: a\n      // component that nests itself recurses through here, so one extra frame\n      // per level is one fewer level before the stack gives out - enough, when\n      // this was a shared `paint()`, to overflow *underneath* the depth guard\n      // at MAX_NESTING_DEPTH and turn a named error back into a RangeError\n      this.endMarker.parentNode!.insertBefore(renderNodes(this.template, templateScope, fx, shadow), this.endMarker)\n      this.renderDone = true\n      this.settleMounted()\n    } else {\n      Promise.all(gates).then(() => {\n        // destroy() nulls the markers and a re-render replaces them, so a gate\n        // that opens after either one has nothing left to paint into\n        if (marker !== this.startMarker) return\n        this.endMarker!.parentNode!.insertBefore(renderNodes(this.template, templateScope, fx, shadow), this.endMarker!)\n        this.renderDone = true\n        this.settleMounted()\n      })\n      warnIfStuck(this, gates)\n    }\n\n    if (shadow) {\n      this.styleEls = this.styles.map(style => {\n        const el = document.createElement(\"style\")\n        el.textContent = style.content // the source: a shadow root scopes it already\n        return el\n      })\n    } else {\n      this.styles.forEach(style => acquireStyle(headStyle(style)))\n      this.ownsSharedStyles = true\n    }\n\n    return this\n  }\n\n  // renders (when needed) and attaches in one call: the component is rendered\n  // on the first mount, and re-rendered fresh whenever `data` is passed.\n  // mount(el) on an already-rendered component just re-attaches, keeping its\n  // state - the detach()/mount() round trip. Rendering here keeps whichever\n  // style mode was last used (document.head unless renderShadow/mountShadow\n  // chose a shadow root)\n  mount(parent: Element | ShadowRoot | DocumentFragment | string, data?: Record<string, any>): this {\n    const target = typeof parent === \"string\" ? $(parent) : parent\n    if (!target) throw new Error(`mount target not found: ${parent}`)\n    if (!this.content || data !== undefined) this.renderWith(data ?? {}, this.useShadow)\n    return this.attach(target)\n  }\n\n  // like mount(), but renders with styles scoped to a shadow root on the\n  // target instead of document.head\n  mountShadow(parent: Element | ShadowRoot | DocumentFragment | string, data?: Record<string, any>): this {\n    const target = typeof parent === \"string\" ? $(parent) : parent\n    if (!target) throw new Error(`mount target not found: ${parent}`)\n    if (!this.content || data !== undefined || !this.useShadow) this.renderWith(data ?? {}, true)\n    return this.attach(target)\n  }\n\n  private attach(target: Element | ShadowRoot | DocumentFragment): this {\n    if (this.mountRoot) this.detach()\n\n    const root = this.useShadow && target instanceof Element\n      ? target.shadowRoot ?? target.attachShadow({ mode: \"open\" })\n      : target\n    if (this.useShadow) this.styleEls.forEach(el => root.appendChild(el))\n    root.appendChild(this.content!)\n    this.mountRoot = root\n    this.settleMounted()\n    return this\n  }\n\n  // `await $mounted()` means \"rendered and on the page\", so it waits for both -\n  // whichever lands last calls this. In the ordinary synchronous flow the render\n  // is already done and this is the attach; for a component whose first render\n  // a script held back, it is the other way round\n  private settleMounted() {\n    if (this.renderDone && this.mountRoot) this.resolveMounted?.()\n  }\n\n  // detaches from the DOM while keeping all state; a later mount() re-attaches\n  // with any updates that happened while detached already applied\n  detach(): this {\n    if (!this.mountRoot || !this.content || !this.startMarker || !this.endMarker) return this\n\n    // move everything between the markers (inclusive) back into the holding\n    // fragment - including nodes :if/:each inserted after mounting\n    let node: Node | null = this.startMarker\n    while (node) {\n      const nextNode: Node | null = node.nextSibling\n      this.content.appendChild(node)\n      if (node === this.endMarker) break\n      node = nextNode\n    }\n\n    this.mountRoot = null\n    return this\n  }\n\n  destroy(): this {\n    this.detach()\n    this.fx?.dispose()\n    this.fx = null\n    // a store this component was handed (a shared `$reactive`) outlives it, and\n    // holds a listener per store that nested it - drop this instance's\n    this.data?.$dispose()\n    this.styleEls.forEach(el => el.parentNode?.removeChild(el))\n    this.styleEls = []\n    if (this.ownsSharedStyles) {\n      this.styles.forEach(style => releaseStyle(headStyle(style)))\n      this.ownsSharedStyles = false\n    }\n    this.content = null\n    this.startMarker = null\n    this.endMarker = null\n    this.renderDone = false\n    this.data = null\n    this.resolveMounted = null\n    return this\n  }\n}\n\n// what Component79.fetch() hands back: a component that hasn't arrived yet.\n//\n// Every method queues onto the fetch and returns the handle, so a whole page\n// is one expression and the calls run in the order they were written:\n//\n//   C79.fetch(\"./app.html\").on(\"save\", persist).mount(\"main\", { user })\n//\n// It is also thenable, resolving to the Component79 itself - which is what\n// keeps `await Component79.fetch(url)` (and importResource, and a handle\n// dropped into Promise.all) working exactly as before. Queued calls keep the\n// resolved value, so awaiting a chain gives the mounted component.\n//\n// The catch: mount() here returns the handle, not the component - there is no\n// component yet to return. That's why the whole lifecycle is on the handle and\n// not just mount(): nobody should have to await merely to destroy something.\nexport class PendingComponent79 {\n  // the fetch with every queued call chained onto it, each passing the\n  // component through - so `chain` always settles to the component, however\n  // many calls were queued, and a failure anywhere rejects the rest\n  private chain: Promise<Component79>\n\n  constructor(component: Promise<Component79>) {\n    this.chain = component\n  }\n\n  private queue(action: (component: Component79) => void): this {\n    this.chain = this.chain.then(component => {\n      action(component)\n      return component\n    })\n    return this\n  }\n\n  then<TResult1 = Component79, TResult2 = never>(\n    onfulfilled?: ((value: Component79) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult1 | TResult2> {\n    return this.chain.then(onfulfilled, onrejected)\n  }\n\n  // a chain nobody awaits reports a failed fetch as an unhandled rejection,\n  // like any dropped promise chain - these are for callers who'd rather handle\n  // it. catch() returns a promise, not a handle: the chain ends here\n  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<Component79 | TResult> {\n    return this.chain.catch(onrejected)\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<Component79> {\n    return this.chain.finally(onfinally)\n  }\n\n  mount(parent: Element | ShadowRoot | DocumentFragment | string, data?: Record<string, any>): this {\n    return this.queue(component => component.mount(parent, data))\n  }\n\n  mountShadow(parent: Element | ShadowRoot | DocumentFragment | string, data?: Record<string, any>): this {\n    return this.queue(component => component.mountShadow(parent, data))\n  }\n\n  render(data: Record<string, any> = {}): this {\n    return this.queue(component => component.render(data))\n  }\n\n  renderShadow(data: Record<string, any> = {}): this {\n    return this.queue(component => component.renderShadow(data))\n  }\n\n  on(eventName: string, listener: EmitListener): this {\n    return this.queue(component => component.on(eventName, listener))\n  }\n\n  off(eventName: string, listener: EmitListener): this {\n    return this.queue(component => component.off(eventName, listener))\n  }\n\n  detach(): this {\n    return this.queue(component => component.detach())\n  }\n\n  destroy(): this {\n    return this.queue(component => component.destroy())\n  }\n}\n\nexport { Component79 as C79 }\n\nexport const parseComponent = (component: string): Component79 => new Component79(component)\n\n// library helpers injected into setup scripts. They behave like extra\n// globals: a same-named scope property (render data or a top-level\n// declaration) shadows them\nconst SETUP_HELPERS: Record<string, any> = { $, $$, $create, $reactive, $toRaw, Component79 }\n\n// the hot-reload handshake. jq79/dev serves a classic script that sets the flag\n// below; classic scripts run before deferred module ones, so the flag is always\n// set before this module evaluates. The page's copy of the runtime can come from\n// anywhere - a CDN, an import map, dist/ - and the dev client has no way to\n// import *that* copy, so the runtime hands itself to the client instead\nif (typeof globalThis !== \"undefined\" && (globalThis as any)[HOT_FLAG]) enableHotReload()\n\n","// DOM helpers: tiny query/create utilities, also injected into component\n// scripts as $, $$ and $create\n\n// $(selector) queries the document; $(el, selector) queries within el. The\n// selector is required in the element form - an empty one is a SyntaxError\nexport function $(selector: string): Element | null\nexport function $(el: Element, selector: string): Element | null\nexport function $(selectorOrEl: string | Element, selector?: string): Element | null {\n  return typeof selectorOrEl === \"string\"\n    ? document.querySelector(selectorOrEl)\n    : selectorOrEl.querySelector(selector!)\n}\n\nexport function $$(selector: string): Element[]\nexport function $$(el: Element, selector: string): Element[]\nexport function $$(selectorOrEl: string | Element, selector?: string): Element[] {\n  return Array.from(\n    typeof selectorOrEl === \"string\"\n      ? document.querySelectorAll(selectorOrEl)\n      : selectorOrEl.querySelectorAll(selector!)\n  )\n}\n\n// $create(tag, attrs): attrs are set as attributes, except className, which\n// may be a string or an array of class names.\nexport const $create = (tag: string, attrs: Record<string, any> = {}): HTMLElement => {\n  const el = document.createElement(tag);\n  for (const [name, value] of Object.entries(attrs)) {\n    if (name === 'className') {\n      el.className = Array.isArray(value) ? value.join(' ') : value;\n    } else if (name === 'textContent') {\n      el.textContent = value;\n    } else if (name === 'children') {\n      for (const child of value) {\n        el.appendChild(child);\n      }\n    } else {\n      el.setAttribute(name, value);\n    }\n  }\n  return el;\n};\n\nconst ALLOWED_TAGS = new Set([\n  'a', 'b', 'i', 'em', 'strong', 'p', 'br', 'ul', 'ol', 'li',\n  'blockquote', 'code', 'pre', 'span', 'div', 'h1', 'h2', 'h3',\n  'h4', 'h5', 'h6', 'img'\n]);\n\nconst ALLOWED_ATTR: Record<string, Set<string>> = {\n  a: new Set(['href', 'title']),\n  img: new Set(['src', 'alt']),\n  '*': new Set(['class']), // atributos permitidos en cualquier tag\n};\n\nconst SAFE_URL_PROTOCOLS = new Set(['http:', 'https:', 'mailto:']);\n\nexport function isSafeUrl(value: string): boolean {\n  try {\n    // resolver relativo a algo neutro para poder leer el protocolo\n    const url = new URL(value, 'https://example.com');\n    return SAFE_URL_PROTOCOLS.has(url.protocol);\n  } catch {\n    return false;\n  }\n}\n\n// la política de destinos: decide si un href/src ya seguro por protocolo\n// puede apuntar a donde apunta. Restringe *sobre* el chequeo de protocolo,\n// nunca en su lugar\nexport type AllowUrl = (url: URL, tag: string, attr: string) => boolean;\n\nexport type SanitizeOptions = { allowUrl?: AllowUrl };\n\nconst DEFAULT_PORTS: Record<string, string> = { 'https:': '443', 'http:': '80' };\n\ntype HostPattern = { host: RegExp; port: string | null };\n\n// \"host[:puerto]\": `*` casa exactamente UNA etiqueta dns - la regla de los\n// certificados TLS, no la de CSP: *.germade.dev casa a.germade.dev, pero ni\n// germade.dev (escribe los dos para incluir el apex) ni a.b.germade.dev.\n// Sin puerto casa cualquiera; un patrón inválido devuelve null y no casa\n// nada - una política rota cierra, no abre\nfunction compileHostPattern(pattern: string): HostPattern | null {\n  const match = pattern.trim().toLowerCase().match(/^([a-z\\d*][a-z\\d.*-]*?)(?::(\\d{1,5}|\\*))?$/);\n  if (!match) return null;\n  const [, host, port] = match;\n  const labels = host.split('.');\n  if (labels.some(label => label !== '*' && !/^[a-z\\d-]+$/.test(label))) return null;\n  // las etiquetas validadas no llevan metacaracteres de regex, así que no\n  // hay nada que escapar; los puntos los pone el join\n  const re = new RegExp(`^${labels.map(label => (label === '*' ? '[^.]+' : label)).join('\\\\.')}$`);\n  return { host: re, port: !port || port === '*' ? null : port };\n}\n\n// compila una lista de patrones (string separado por comas, o array) en un\n// predicado AllowUrl. El puerto comparado es el *efectivo* de la URL (el\n// explícito, o el del esquema), así \"germade.dev:443\" casa https://germade.dev.\n// Una URL sin host (mailto:) no casa ningún patrón: los patrones hablan de\n// hosts - la forma función de la política puede admitirla si quiere\nexport const allowedHosts = (patterns: string | string[]): AllowUrl => {\n  const compiled = (Array.isArray(patterns) ? patterns : patterns.split(','))\n    .map(compileHostPattern)\n    .filter((p): p is HostPattern => p !== null);\n  return url => {\n    const host = url.hostname.toLowerCase();\n    const port = url.port || DEFAULT_PORTS[url.protocol] || '';\n    return compiled.some(p => p.host.test(host) && (p.port === null || p.port === port));\n  };\n};\n\n// consulta la política con la URL resuelta contra la página, para que una\n// URL relativa se juzgue como el destino same-origin que realmente es. Un\n// predicado que lanza, o una URL que no parsea, es un no\nfunction consultAllowUrl(allowUrl: AllowUrl, value: string, tag: string, attr: string): boolean {\n  try {\n    return !!allowUrl(new URL(value, document.baseURI), tag, attr);\n  } catch {\n    return false;\n  }\n}\n\n// el saneado es recursivo, así que la profundidad del input es profundidad\n// de pila. 512 es lo que toleran los parsers de los navegadores antes de\n// aplanar el anidamiento, con lo que ningún documento legítimo pierde nada -\n// y superar el límite lanza un RangeError con nombre, en vez de reventar la\n// pila en algún punto indeterminado más arriba\nconst MAX_SANITIZE_DEPTH = 512;\n\n// copia los hijos de `source` en `target`, saneando los elementos y clonando\n// el texto; cualquier otra cosa (comentarios, etc.) se descarta\nfunction appendSanitizedChildren(source: ParentNode, target: HTMLElement, depth: number, allowUrl?: AllowUrl): void {\n  if (depth > MAX_SANITIZE_DEPTH) {\n    throw new RangeError(`jq79: sanitizeHTML input nests deeper than ${MAX_SANITIZE_DEPTH} elements`);\n  }\n  for (const child of Array.from(source.childNodes)) {\n    if (child.nodeType === Node.ELEMENT_NODE) {\n      const sanitizedChild = sanitizeNode(child as HTMLElement, depth, allowUrl);\n      if (sanitizedChild) target.appendChild(sanitizedChild);\n    } else if (child.nodeType === Node.TEXT_NODE) {\n      target.appendChild(child.cloneNode());\n    }\n  }\n}\n\n// sanea un elemento (los llamadores solo pasan nodos ELEMENT_NODE)\nfunction sanitizeNode(node: HTMLElement, depth: number, allowUrl?: AllowUrl): HTMLElement | null {\n  const tag = node.tagName.toLowerCase();\n  if (!ALLOWED_TAGS.has(tag)) return null; // tag no permitido → se descarta el nodo entero\n\n  const clean = document.createElement(tag);\n\n  for (const attr of Array.from(node.attributes)) {\n    const name = attr.name.toLowerCase();\n    const allowedForTag = ALLOWED_ATTR[tag]?.has(name);\n    const allowedGlobal = ALLOWED_ATTR['*']?.has(name);\n    if (!allowedForTag && !allowedGlobal) continue;\n\n    if (name === 'href' || name === 'src') {\n      if (!isSafeUrl(attr.value)) continue;\n      if (allowUrl && !consultAllowUrl(allowUrl, attr.value, tag, name)) continue;\n    }\n\n    clean.setAttribute(name, attr.value);\n  }\n\n  // fuerza rel seguro en enlaces (target nunca se copia: no está permitido)\n  if (tag === 'a') clean.setAttribute('rel', 'noopener noreferrer');\n\n  appendSanitizedChildren(node, clean, depth + 1, allowUrl);\n\n  return clean;\n}\n\nexport function sanitizeHTML(html: string, options?: SanitizeOptions): string {\n  // parsear con <template> en vez de con DOMParser: el contenido de un template\n  // es un documento inerte igual (ni scripts ni imágenes se ejecutan al asignar\n  // innerHTML), pero el parseo de fragmento conserva el espacio en blanco inicial\n  // que el modo \"before body\" de un documento completo descartaría - así una\n  // primera línea indentada (un diff, un <pre>) llega con su sangría intacta\n  const template = document.createElement('template');\n  template.innerHTML = html;\n  const container = document.createElement('div');\n\n  appendSanitizedChildren(template.content, container, 0, options?.allowUrl);\n\n  return container.innerHTML;\n}","// the reactive store ($reactive): proxy-based deep reactivity with\n// dot-path dependency tracking, plus the effect-scope helper the renderer\n// uses to tear down a subtree's bindings in one call\n\ntype ChangeListener = (value: any, dotKey: string) => void\ntype AnyChangeListener = (dotKey: string, value: any) => void\ntype ListenerOptions = { immediate?: boolean }\ntype Unsubscribe = () => void\n\nexport type EffectOptions = {\n  // wake this effect for writes below its dependencies, not only on them\n  deep?: boolean\n  // internal: the extra stores this effect must also be registered with, so a\n  // change in any of them wakes it (see ATTACH). Slot content is the only\n  // thing that sets it, by way of createEffectScope - it is deliberately not\n  // part of what this API tells users about\n  alsoWakenBy?: Record<string, any>[]\n}\n\nexport type ReactiveDeepData<T> = T & {\n  $on: (dotKey: string, listener: ChangeListener, options?: ListenerOptions) => Unsubscribe\n  $onAny: (listener: AnyChangeListener, options?: ListenerOptions) => Unsubscribe\n  // runs `run` immediately, recording every dotKey it reads off this store, then\n  // re-runs it whenever a changed dotKey overlaps one of those - see TrieNode.\n  //\n  // `deep` also wakes it for writes *below* what it read. It is for the one\n  // shape the store cannot see into: an effect that hands a value to code\n  // outside its view - a chart library, a canvas, a request - and so reads\n  // nothing the proxy can record (see docs/reactive-data.md)\n  $effect: (run: () => void, options?: EffectOptions) => Unsubscribe\n  // drops this store's subscriptions to the stores nested inside it (see\n  // bridge). A store that outlives the one holding it - the shared-state case -\n  // would otherwise keep the dead holder's listeners on its own list forever\n  $dispose: () => void\n}\n\nconst getByPath = (obj: Record<string, any>, dotKey: string): any =>\n  dotKey.split(\".\").reduce((acc, key) => (acc == null ? undefined : acc[key]), obj)\n\n// only plain objects and arrays get deep-wrapped by the reactive store;\n// class instances (Component79, Date, DOM nodes, ...) pass through untouched\n// so their identity, prototypes and internals stay intact\nconst isPlainData = (value: object): boolean => {\n  if (Array.isArray(value)) return true\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n\nconst walkLeaves = (obj: Record<string, any>, path: string, visit: (dotKey: string, value: any) => void) => {\n  Object.entries(obj).forEach(([key, value]) => {\n    const dotKey = path ? `${path}.${key}` : key\n    if (value && typeof value === \"object\" && isPlainData(value)) walkLeaves(value, dotKey, visit)\n    else visit(dotKey, value)\n  })\n}\n\n// Effect deps live in a trie keyed by path segment: a write walks down its own\n// segments, so the nodes it passes through are its ancestors and the subtree it\n// lands on is its descendants, with no comparison against unrelated effects.\n// `own` holds effects depending on this node's exact path; `deep` holds the ones\n// that want everything under it too (see the `deep` flag on $effect).\n//\n// Which of the two directions actually wakes an effect is the thing that makes\n// this fast, and it is not symmetric - see effectsFor and\n// TODOS/2026-08-23.narrow-the-wake-rule.md\n//\n// `children`/`own`/`deep` are allocated on first use and `parent`/`segment` let\n// a removal walk back up without re-splitting the path: a 10,000-row table is\n// ~40,000 nodes, and three eager allocations each (a Map and two Sets, almost\n// all of them staying empty) cost more than the index saves\ntype TrieNode = {\n  children: Map<string, TrieNode> | null\n  own: Set<Effect> | null\n  deep: Set<Effect> | null\n  parent: TrieNode | null\n  segment: string\n}\n\n// the dep an `ownKeys` read records, as a reserved last segment on the\n// enumerated object's own path: an ordinary trie child that no walk for a real\n// key can reach, and that the subtree sweep still reaches when the whole object\n// is replaced - which is correct, a new object is a new key set. A real\n// property named \" keys\" collides with it, the same way a flat key containing\n// a dot collides with the nested path of the same name (tests/reactive.test.ts)\nconst KEYS_SEGMENT = \" keys\"\n\nconst keysPath = (path: string): string => (path ? `${path}.${KEYS_SEGMENT}` : KEYS_SEGMENT)\n\nconst createTrieNode = (parent: TrieNode | null, segment: string): TrieNode =>\n  ({ children: null, own: null, deep: null, parent, segment })\n\nconst isEmptyNode = (node: TrieNode): boolean =>\n  !node.own?.size && !node.deep?.size && !node.children?.size\n\n// reads the raw object behind a store proxy. Module-level (not per-store) so a\n// value that is already reactive - in this store or in another one - can be\n// unwrapped before being wrapped again. Without it, handing the same object to\n// two stores has each one wrapping the other's proxies, and since a wrap walks\n// what it wraps, the nesting compounds until the process stops responding\nconst RAW = Symbol(\"jq79.raw\")\n\n// a free function rather than a method on the store, because the store API is\n// served from the root proxy alone (see storeApi): `store.$toRaw()` would work\n// and `store.user.$toRaw()` would not, which is the case callers actually have.\n// The RAW symbol travels on every proxy at every depth, so this works anywhere.\n// What it returns is the real object, not a copy: writes to it notify nobody\nexport const $toRaw = <T>(value: T): T => {\n  let raw: any = value\n  while (raw !== null && typeof raw === \"object\" && raw[RAW]) raw = raw[RAW]\n  return raw\n}\n\n// marks a store's *root* proxy. A store put inside another store (a setup\n// script's `const local = $reactive(...)`) has to pass through whole: it owns\n// its listeners and its $on/$effect, so unwrapping it would strip away the very\n// thing it is. Nested proxies carry no such marker and are unwrapped freely\nconst STORE = Symbol(\"jq79.store\")\n\nconst isStore = (value: any): boolean =>\n  value !== null && typeof value === \"object\" && value[STORE] === true\n\n// active $effect() runs, innermost last - a module-level stack (rather than\n// one per store) so nested effects across stores still nest correctly; reads\n// during a proxy's `get` trap are attributed to whichever run is on top\nconst trackerStack: Set<string>[] = []\n\n// runs fn with dependency tracking suspended - reads inside it are attributed\n// to a throwaway set instead of the currently running effect\nexport const untracked = <T>(fn: () => T): T => {\n  trackerStack.push(new Set())\n  try {\n    return fn()\n  } finally {\n    trackerStack.pop()\n  }\n}\n\n// `reindex` holds one callback per store this effect is registered with (its\n// own, plus any it was attached to), each keeping that store's trie in step\n// with the deps of the last settled run. It lives on the effect rather than\n// in a per-store map because `run` has to reach it without a lookup\ntype Effect = { deps: Set<string>; run: () => void; reindex: Set<(deps: Set<string>) => void>; deep: boolean; order: number }\n\n// creation order, module-wide. The flat `effects` set used to give this for\n// free - iterating it ran effects oldest-first, so a parent's bindings always\n// went before those of a child it had rendered. Matching through the trie\n// returns them in walk order instead, and the tutorial's setup scripts are\n// sensitive to it (a child effect running before its parent's re-sync reads\n// state the parent has not written yet). Effects are ordered explicitly rather\n// than left to whatever the index happens to yield\nlet effectsCreated = 0\n\n// the deps an effect has before its first run, and what indexEffect compares\n// its first run against. Never written to - every run installs a fresh set -\n// so one frozen instance stands in for the two empty sets each effect used to\n// allocate. 30,000 effects is 60,000 of them\nconst NO_DEPS: ReadonlySet<string> = new Set()\n\n// an effect lives in exactly one store's `effects` set - the one whose\n// $effect created it - and only that store's notify walks it. Content that\n// reads two stores at once (a component's slot content: the parent's names\n// plus the slot props the child passes it) needs one record in both sets, so\n// a store serves this attach handle beside $on/$effect. Tracking already\n// spans stores - trackerStack is module-level, so one run's deps are whatever\n// it read, wherever it read it - only the waking didn't.\n//\n// Named like the compiled scripts' internals ($__effect, $__import) because it\n// is one: `key in store` never answers true for a storeApi name, so `with`\n// can't see it and no template expression can reach it.\n//\n// The cost, accepted: deps are dot-paths with no store namespace, so a name\n// that exists in both stores wakes the effect from either. A spurious re-run,\n// never a stale render\nconst ATTACH = \"$__attach\"\n\n// the extra stores every effect created off a scope must be attached to. Read\n// by createEffectScope off the scope it is given, so a scope can hand the\n// arrangement down to whatever renders inside it (nested :each item scopes,\n// a nested component's prop-sync effects) without every call site knowing\nexport const ALSO_WAKEN_BY = Symbol(\"jq79.alsoWakenBy\")\n\nexport const $reactive = <T extends Record<string, any>>(data: T): ReactiveDeepData<T> => {\n  const exactListeners = new Map<string, Set<ChangeListener>>()\n  const anyListeners = new Set<AnyChangeListener>()\n  const effects = new Set<Effect>()\n\n  // one proxy per raw object, for this store alone. Keyed by the *raw object*\n  // rather than by its path, so identity travels with the object: :each diffs\n  // its items by reference (Object.is), and a reordered list has to hand back\n  // the same proxy for the same item or every row would re-render. The flip\n  // side is that an object's path is fixed when it is first wrapped, so after a\n  // reorder its notifications carry the old index - effects that read the list\n  // itself still wake up (they hold its ancestor as a dep), which is what makes it a non-issue in\n  // practice\n  const proxies = new WeakMap<object, Record<string, any>>()\n\n  // $on/$onAny/$effect are served from the root proxy's `get` instead of being\n  // defined on the object: a store must leave nothing behind on the data it was\n  // handed, and two stores over one object would otherwise clobber each other's\n  // handles. Null-prototype, so `key in storeApi` can't match Object.prototype\n  const storeApi: Record<string, any> = Object.create(null)\n\n  // this store's dep index (see TrieNode). Segments come from splitting a\n  // dotKey on \".\", which is also why a flat key written as \"a.b\" indexes\n  // exactly where the nested a.b lives - the collision dot-paths have always\n  // had, preserved rather than special-cased\n  const depTrie = createTrieNode(null, \"\")\n\n  // hands back the node it registered on, which is what lets a removal skip the\n  // path entirely (see indexEffect)\n  const insertDep = (dep: string, effect: Effect): TrieNode => {\n    let node = depTrie\n    dep.split(\".\").forEach(segment => {\n      const children = (node.children ??= new Map())\n      let child = children.get(segment)\n      if (!child) {\n        child = createTrieNode(node, segment)\n        children.set(segment, child)\n      }\n      node = child\n    })\n    ;((effect.deep ? (node.deep ??= new Set()) : (node.own ??= new Set()))).add(effect)\n    return node\n  }\n\n  // prunes the nodes it empties on the way back up, so a list that churns\n  // through rows doesn't leave the trie growing over the dead ones. Follows\n  // `parent` rather than re-walking from the root: tearing down a 10,000-row\n  // table is 30,000 of these, and splitting each path again to find a node the\n  // caller was already holding is most of what that used to cost\n  const removeDep = (node: TrieNode, effect: Effect) => {\n    ;(effect.deep ? node.deep : node.own)?.delete(effect)\n    let current: TrieNode | null = node\n    while (current?.parent && isEmptyNode(current)) {\n      current.parent.children!.delete(current.segment)\n      current = current.parent\n    }\n  }\n\n  const nodeAt = (dep: string): TrieNode | undefined => {\n    let node: TrieNode | undefined = depTrie\n    for (const segment of dep.split(\".\")) {\n      node = node.children?.get(segment)\n      if (!node) return undefined\n    }\n    return node\n  }\n\n  // every effect this write concerns. Two directions, and they are not\n  // symmetric:\n  //\n  // - **downwards**, always: whatever hangs off the node the walk lands on. A\n  //   dep of \"user.name\" hears `user = {...}`, because replacing the object\n  //   replaced the name with it.\n  // - **upwards**, only where an ancestor dep is the only channel a change\n  //   has (see `coarsePath`). A dep of \"data\" does NOT hear\n  //   `data[5].label = x`: an effect that read the array on its way to row\n  //   7's label has no stake in row 5's, and waking all of them is what made\n  //   100 row writes cost 100,000 effect runs - see\n  //   TODOS/2026-08-23.narrow-the-wake-rule.md\n  //\n  // Returned as a snapshot, so the effects it wakes can reindex themselves -\n  // or dispose each other - while it drains\n  const effectsFor = (dotKey: string): Set<Effect> => {\n    const matched = new Set<Effect>()\n    const sweep = (from: TrieNode) => {\n      const pending = from.children ? [...from.children.values()] : []\n      while (pending.length) {\n        const next = pending.pop()!\n        next.own?.forEach(effect => matched.add(effect))\n        next.deep?.forEach(effect => matched.add(effect))\n        next.children?.forEach(child => pending.push(child))\n      }\n    }\n\n    let node: TrieNode | undefined = depTrie\n    const segments = dotKey.split(\".\")\n    let path = \"\"\n    for (let depth = 0; depth < segments.length - 1; depth++) {\n      node = node.children?.get(segments[depth])\n      if (!node) return matched\n      path = path ? `${path}.${segments[depth]}` : segments[depth]\n      node.deep?.forEach(effect => matched.add(effect))\n      // a nested store sits here: an effect that read through it holds this\n      // path and nothing below it, so its own set is the whole channel\n      if (bridges.has(path)) node.own?.forEach(effect => matched.add(effect))\n      // ...whereas an array's length stands for the array: everything that\n      // read an element has to hear a truncation, and those deps are below\n      if (depth === segments.length - 2 && segments[depth + 1] === \"length\") {\n        node.own?.forEach(effect => matched.add(effect))\n        sweep(node)\n      }\n    }\n    node = node.children?.get(segments[segments.length - 1])\n    if (!node) return matched\n    node.own?.forEach(effect => matched.add(effect))\n    node.deep?.forEach(effect => matched.add(effect))\n    sweep(node)\n    return matched\n  }\n\n  // Reaching `data[5].label` reads three paths and tracks all three, but for an\n  // ordinary effect the two ancestors carry no information the leaf doesn't: a\n  // write to \"data\" or \"data.5\" reaches \"data.5.label\" through the subtree\n  // sweep anyway. Dropping them is a third of the index to build, hold and tear\n  // down on a list of any size.\n  //\n  // Not for a `deep` effect, where it is exactly backwards - a forwarding\n  // effect wakes off its *ancestor* entries, so its shallowest dep is the one\n  // doing the work and the leaves are the redundant ones\n  const indexable = (effect: Effect, deps: Set<string>): Set<string> => {\n    if (effect.deep || deps.size < 2) return deps\n    // every ancestor of every dep is redundant, so mark them by walking each\n    // dep's own dots rather than comparing deps against each other: a `:each`\n    // over 10,000 rows tracks 10,000 deps, and the pairwise version of this\n    // was 100,000,000 string comparisons\n    const redundant = new Set<string>()\n    deps.forEach(dep => {\n      for (let dot = dep.indexOf(\".\"); dot !== -1; dot = dep.indexOf(\".\", dot + 1)) {\n        redundant.add(dep.slice(0, dot))\n      }\n    })\n    if (!redundant.size) return deps\n    const kept = new Set<string>()\n    deps.forEach(dep => { if (!redundant.has(dep)) kept.add(dep) })\n    return kept\n  }\n\n  // registers `effect` with this store's trie and keeps it in step. Each store\n  // tracks what it indexed for the effect separately, because a detach must\n  // clear this trie without touching the others\n  const indexEffect = (effect: Effect): Unsubscribe => {\n    // dep -> the node it sits on, so removal never re-walks a path: the\n    // overwhelmingly common re-run has identical deps and touches the trie not\n    // at all, and a disposal goes straight to the nodes it registered\n    // almost every effect ends up with exactly one dep once the redundant\n    // ancestors are pruned - a row binding reads one path - so the single case\n    // is held in two slots and the Map is allocated only when a second arrives\n    let soleDep: string | null = null\n    let soleNode: TrieNode | null = null\n    let indexed: Map<string, TrieNode> | null = null\n    // what the last run tracked, before pruning. The comparison has to happen\n    // against these rather than against what is indexed, because pruning them\n    // is itself work this fast path exists to skip\n    let lastTracked: ReadonlySet<string> = NO_DEPS\n\n    const placed = (dep: string): boolean =>\n      indexed ? indexed.has(dep) : soleDep === dep\n\n    const place = (dep: string) => {\n      const node = insertDep(dep, effect)\n      if (indexed) indexed.set(dep, node)\n      else if (soleDep === null) { soleDep = dep; soleNode = node }\n      else {\n        indexed = new Map([[soleDep, soleNode!], [dep, node]])\n        soleDep = soleNode = null\n      }\n    }\n\n    const unplaceStale = (deps: Set<string>) => {\n      if (indexed) {\n        indexed.forEach((node, dep) => {\n          if (deps.has(dep)) return\n          removeDep(node, effect)\n          indexed!.delete(dep)\n        })\n        return\n      }\n      if (soleDep !== null && !deps.has(soleDep)) {\n        removeDep(soleNode!, effect)\n        soleDep = soleNode = null\n      }\n    }\n\n    const unplaceAll = () => {\n      if (indexed) indexed.forEach(node => removeDep(node, effect))\n      else if (soleNode) removeDep(soleNode, effect)\n      indexed = null\n      soleDep = soleNode = null\n    }\n    const sync = (tracked: Set<string>) => {\n      // an effect that re-runs almost always reads exactly what it read last\n      // time, and this is on the path of every single run: same count and every\n      // path seen before means nothing about the index can have changed\n      if (tracked.size === lastTracked.size) {\n        let unchanged = true\n        tracked.forEach(dep => { unchanged &&= lastTracked.has(dep) })\n        if (unchanged) return\n      }\n      lastTracked = tracked\n      const deps = indexable(effect, tracked)\n      unplaceStale(deps)\n      deps.forEach(dep => { if (!placed(dep)) place(dep) })\n    }\n    effect.reindex.add(sync)\n    sync(effect.deps) // an effect attached after it first ran arrives with deps\n    return () => {\n      effect.reindex.delete(sync)\n      unplaceAll()\n      lastTracked = NO_DEPS\n    }\n  }\n\n  // wakes the effects sitting on one exact path, without the subtree sweep a\n  // full notify does. Two callers want this: a key-set change (nothing under\n  // the object changed, only which keys it has) and a container replaced by one\n  // holding the same elements (see notifyReplaced)\n  const wakeExactly = (dep: string) => {\n    const node = nodeAt(dep)\n    if (node) runMatched(new Set([...(node.own ?? []), ...(node.deep ?? [])]))\n  }\n\n  // an object's key set changed. Effects only - a key set isn't a value, so\n  // there is nothing to hand $on/$onAny that they don't already get from the\n  // key's own notification\n  const notifyKeys = (path: string) => wakeExactly(keysPath(path))\n\n  // oldest first, and re-checking membership as it goes: an effect disposed by\n  // an earlier one in this same pass (a list diff tearing down the rows it just\n  // woke) must not run\n  const runMatched = (matched: Set<Effect>) => {\n    const ordered = Array.from(matched)\n    // effects are usually collected in creation order already - one node's set\n    // is filled as its effects are made, and a subtree sweep of a freshly-built\n    // list walks them the same way. Checking costs one pass; sorting a woken\n    // set of 10,000 costs rather more\n    let sorted = true\n    for (let i = 1; sorted && i < ordered.length; i++) sorted = ordered[i - 1].order < ordered[i].order\n    if (!sorted) ordered.sort((a, b) => a.order - b.order)\n    ordered.forEach(effect => { if (effects.has(effect)) effect.run() })\n  }\n\n  const notify = (dotKey: string, value: any, isNewKey = false) => {\n    exactListeners.get(dotKey)?.forEach(listener => listener(value, dotKey))\n    anyListeners.forEach(listener => listener(dotKey, value))\n    // a newly-created key re-runs every effect: an effect that read the\n    // name while it didn't exist couldn't track it (`with` skipped the\n    // store entirely), so dep matching would never wake it up\n    if (isNewKey) effects.forEach(effect => effect.run())\n    // `effects.has` stands in for the membership check `effects.forEach` used\n    // to give for free: an effect disposed by an earlier effect in this same\n    // notify (a list diff tearing down the rows it just woke) must not run\n    else runMatched(effectsFor(dotKey))\n  }\n\n  // both sides are containers of the same kind, so what changed can be asked\n  // rather than assumed. Not the same object - that case never gets here (a\n  // same-reference write is the deep-touch channel and stays loud), and not a\n  // store on either side, which passes through whole\n  const replaceable = (previous: any, next: any): boolean =>\n    previous !== next &&\n    previous !== null && next !== null &&\n    typeof previous === \"object\" && typeof next === \"object\" &&\n    !isStore(previous) && !isStore(next) &&\n    isPlainData(previous) && isPlainData(next) &&\n    Array.isArray(previous) === Array.isArray(next)\n\n  const keyCount = (container: any): number =>\n    Array.isArray(container) ? container.length : Object.keys(container).length\n\n  // which keys hold a different value than they did, or null when so many do\n  // that notifying them one at a time would cost more than sweeping the\n  // container. Arrays - the case this exists for - are walked by index, so a\n  // 10,000 element list is compared without building a key array or a set of\n  // them: that bookkeeping alone was costing more than it saved on every\n  // replacement that ends up sweeping anyway\n  const GIVE_UP: null = null\n\n  const whatChanged = (previous: any, next: any): string[] | null => {\n    if (Array.isArray(next)) {\n      const before = previous.length\n      const after = next.length\n      // nothing on one side means nothing to reuse on the other\n      if (!before || !after) return GIVE_UP\n      const span = Math.max(before, after)\n      const changed: string[] = []\n      for (let index = 0; index < span; index++) {\n        if (Object.is($toRaw(previous[index]), $toRaw(next[index]))) continue\n        changed.push(String(index))\n        if (changed.length * 2 >= span) return GIVE_UP\n      }\n      return changed\n    }\n    const keys = new Set([...Object.keys(previous), ...Object.keys(next)])\n    if (!keys.size) return GIVE_UP\n    const changed: string[] = []\n    keys.forEach(key => { if (!Object.is($toRaw(previous[key]), $toRaw(next[key]))) changed.push(key) })\n    return changed.length * 2 >= keys.size ? GIVE_UP : changed\n  }\n\n  // A container replaced by another container: notify the elements that\n  // actually differ instead of the container and everything under it.\n  // `data = [...data, ...more]` holds the very same row objects at every index\n  // it had before, so waking all thirty thousand of their bindings to re-render\n  // identical output is ~150ms of a 208ms append - see\n  // TODOS/2026-08-23.notify-the-difference.md\n  //\n  // One level deep on purpose: an element that differs is a changed value, and\n  // notifying it sweeps its own subtree, which is what a changed value deserves\n  const notifyReplaced = (dotKey: string, previous: any, next: any, notified: any) => {\n    // one write, one wake: every path below contributes to a single set that\n    // runs once at the end. Notifying them one at a time re-ran an effect that\n    // depends on several of them once per path\n    const matched = new Set<Effect>()\n    const collectExact = (dep: string) => {\n      const node = nodeAt(dep)\n      node?.own?.forEach(effect => matched.add(effect))\n      node?.deep?.forEach(effect => matched.add(effect))\n    }\n\n    const changed = whatChanged(previous, next)\n    // when most of the container differs there is nothing to spare: `data = []`\n    // and a wholesale replacement change every key, and reaching each one\n    // through its own trie walk costs more than the single sweep it replaces.\n    // whatChanged says so by giving up. The decision has to come before\n    // anything is announced, or the plain notify would fire the container's\n    // listeners a second time\n    if (!changed) return notify(dotKey, notified)\n\n    exactListeners.get(dotKey)?.forEach(listener => listener(notified, dotKey))\n    // $onAny hears the container and nothing else, exactly as it did when this\n    // was one notify. It is what a bridge re-notifies upstairs, and the holder\n    // sweeps its own side off that one path - announcing each changed element\n    // as well would be a thousand redundant notifications for the same news\n    anyListeners.forEach(listener => listener(dotKey, notified))\n    // the container itself did change: whoever read it, or forwards it whole,\n    // hears that - but nothing is swept on its account\n    collectExact(dotKey)\n\n    changed.forEach(key => {\n      const after = $toRaw(next[key])\n      const child = `${dotKey}.${key}`\n      const value = isWrappable(after) ? wrap(after, child) : after\n      exactListeners.get(child)?.forEach(listener => listener(value, child))\n      effectsFor(child).forEach(effect => matched.add(effect))\n    })\n    if (keyCount(previous) !== keyCount(next)) collectExact(keysPath(dotKey))\n    // an array's length is a real dep (a `:each` reads it on its way through\n    // list.map) and is not one of the keys walked above. Collected exactly:\n    // the sweep a length write normally carries is for a truncation, and the\n    // elements that a shrink dropped are already in `keys`\n    if (Array.isArray(next) && previous.length !== next.length) {\n      const lengthKey = `${dotKey}.length`\n      exactListeners.get(lengthKey)?.forEach(listener => listener(next.length, lengthKey))\n      collectExact(lengthKey)\n    }\n    runMatched(matched)\n  }\n\n  const isWrappable = (value: any): value is Record<string, any> =>\n    value !== null && typeof value === \"object\" && isPlainData(value)\n\n  // a store nested inside this one keeps its own listeners and its own effects,\n  // and this store's effects are not among them - so a write through the inner\n  // store notifies nobody out here, and a component rendering `{{ cart.items }}`\n  // off a `$reactive` it was handed would never update. The holder subscribes\n  // instead, and re-notifies the inner store's changes under the path it sits at\n  // (\"items.0\" -> \"cart.items.0\"). An effect that read through `cart` recorded\n  // exactly that path's ancestor as a dependency, so the trie walk wakes it.\n  // Chains compose: re-notifying runs this store's own $onAny listeners, which\n  // is how a store two levels down still reaches the top\n  const bridges = new Map<string, { store: any; unsubscribe: Unsubscribe }>()\n\n  const bridge = (store: any, path: string) => {\n    const current = bridges.get(path)\n    if (current?.store === store) return\n    current?.unsubscribe()\n    bridges.set(path, {\n      store,\n      unsubscribe: store.$onAny((dotKey: string, value: any) => notify(`${path}.${dotKey}`, value)),\n    })\n  }\n\n  // the key no longer holds the store it held: stop listening to it\n  const unbridge = (path: string) => {\n    bridges.get(path)?.unsubscribe()\n    bridges.delete(path)\n  }\n\n  // the reactive view of `raw`, created on demand. Callers must hand it a raw\n  // object (see $toRaw at both call sites): wrapping a proxy is what compounds\n  const wrap = (raw: Record<string, any>, path: string): Record<string, any> => {\n    const cached = proxies.get(raw)\n    if (cached) return cached\n\n    // keys that were deleted off this object. `with ($scope)` resolves a name\n    // through [[HasProperty]], so without a claim here a deleted key would fall\n    // through to globalThis and the *whole* expression would die of\n    // ReferenceError - `user ? user.name : \"none\"` must take its else branch\n    // instead. The cost: `\"user\" in store` stays true after a delete\n    let tombstones: Set<string> | null = null\n\n    const proxy: Record<string, any> = new Proxy(raw, {\n      has(target, key) {\n        return Reflect.has(target, key) || (typeof key === \"string\" && tombstones?.has(key) === true)\n      },\n      // reading the key set is a dependency of its own: `Object.keys(props)`,\n      // `{...props}`, `for...in` and renderEach's `Object.entries` all care\n      // about which keys exist, not about what any one of them holds. It used\n      // to be caught only by the coarse ancestor rule, which is now gone -\n      // this is the same job Svelte gives a per-object `version` signal, held\n      // as an ordinary trie child under a reserved final segment (see\n      // KEYS_SEGMENT), so adds and deletes wake exactly the effects enumerating\n      ownKeys(target) {\n        trackerStack[trackerStack.length - 1]?.add(keysPath(path))\n        return Reflect.ownKeys(target)\n      },\n      get(target, key, receiver) {\n        if (key === RAW) return target\n        if (key === STORE) return path === \"\"\n        if (typeof key !== \"string\") return Reflect.get(target, key, receiver)\n        if (path === \"\" && key in storeApi) return storeApi[key]\n\n        const dotKey = path ? `${path}.${key}` : key\n        trackerStack[trackerStack.length - 1]?.add(dotKey)\n\n        // nested objects are wrapped here rather than up front, so the object\n        // handed to $reactive is never rewritten\n        const value = Reflect.get(target, key, receiver)\n        if (isStore(value)) {\n          bridge(value, dotKey)\n          return value\n        }\n\n        const raw = $toRaw(value)\n        return isWrappable(raw) ? wrap(raw, dotKey) : raw\n      },\n      set(target, key: string, value, receiver) {\n        // an assignment delegated up the prototype chain from a derived scope\n        // (Object.create(store) child, or a wrapping proxy): if the key isn't\n        // a real property of this store, honor the receiver so the new binding\n        // lands on the derived scope - a scope-local variable, not a store\n        // mutation, so no notify. If the key IS a store property, fall through\n        // and mutate the store itself regardless of receiver, so assignments\n        // like @click=\"count = count + 1\" work from any nested scope\n        if (receiver !== proxy && !Object.prototype.hasOwnProperty.call(target, key)) {\n          return Reflect.set(target, key, value, receiver)\n        }\n\n        const dotKey = path ? `${path}.${key}` : key\n        // store the raw value, never a proxy - including one of our own, so\n        // that `list = [list[1], list[0]]` doesn't write proxies back into the\n        // data. Reads re-wrap it, from the cache, as the very same proxy. A\n        // whole store assigned in is the exception: it stays as it is\n        const stored = isStore(value) ? value : $toRaw(value)\n        const isNewKey = !Object.prototype.hasOwnProperty.call(target, key)\n        // a primitive write that changes nothing notifies nobody: it's what\n        // lets an effect write the value it just read (a normalizing\n        // assignment, a prop sync) and settle instead of waking itself\n        // forever. Only primitives and functions: re-writing the SAME object\n        // reference stays loud, because that is the cross-store \"deep touch\"\n        // channel - a parent's prop sync forwards `user.name = x` to the\n        // child's store by re-assigning the same `user`, and the child's\n        // listeners live on the child's store, not the parent's. A new key\n        // always announces itself - the sweep is its whole point\n        if (!isNewKey && Object.is(target[key], stored) && (stored === null || typeof stored !== \"object\")) return true\n        const previous = target[key]\n        target[key] = stored\n        tombstones?.delete(key) // the key exists again: no claim needed\n        if (isStore(stored)) bridge(stored, dotKey)\n        else unbridge(dotKey)\n        const notified = isStore(stored) || !isWrappable(stored) ? stored : wrap(stored, dotKey)\n        // a new key already re-runs every effect in the store (see notify), so\n        // the key set growing needs no announcement of its own - only a delete,\n        // which wakes precisely, does\n        if (!isNewKey && replaceable(previous, stored)) notifyReplaced(dotKey, previous, stored, notified)\n        else notify(dotKey, notified, isNewKey)\n        return true\n      },\n      // `delete data.user` is a plain-object mutation like any other, so it\n      // notifies like one - with `undefined`, which is what a read returns\n      // afterwards. Array methods that shrink (pop, splice) delete their dead\n      // slots through this trap too. No new-key sweep: whoever depended on the\n      // key tracked it while it existed, so dep matching wakes exactly them\n      deleteProperty(target, key) {\n        if (typeof key !== \"string\") return Reflect.deleteProperty(target, key)\n        const had = Object.prototype.hasOwnProperty.call(target, key)\n        const deleted = Reflect.deleteProperty(target, key)\n        if (deleted && had) {\n          const dotKey = path ? `${path}.${key}` : key\n          ;(tombstones ??= new Set()).add(key)\n          unbridge(dotKey) // a nested store it held: stop listening to it\n          notify(dotKey, undefined)\n          // the key set shrank: whoever enumerated this object hears it even\n          // if it never read the key that went (see the ownKeys trap)\n          notifyKeys(path)\n        }\n        return deleted\n      }\n    })\n\n    proxies.set(raw, proxy)\n    return proxy\n  }\n\n  const reactive = wrap($toRaw(data), \"\") as ReactiveDeepData<T>\n\n  // a store handed in with the data (a prop, or render data) is bridged here\n  // rather than on first read, so a listener registered before anything reads\n  // the key still hears it. Only the top level is scanned: that's where a prop\n  // lands, and descending would mean walking whatever else was handed in - a\n  // highlighter, an API client - to its leaves. A store sitting deeper is\n  // bridged when the read that reaches it wraps its parent\n  Object.entries($toRaw(data)).forEach(([key, value]) => {\n    if (isStore(value)) bridge(value, key)\n  })\n\n  const $on = (dotKey: string, listener: ChangeListener, { immediate = false }: ListenerOptions = {}): Unsubscribe => {\n    if (!exactListeners.has(dotKey)) exactListeners.set(dotKey, new Set())\n    exactListeners.get(dotKey)!.add(listener)\n    if (immediate) listener(getByPath(reactive, dotKey), dotKey)\n    return () => exactListeners.get(dotKey)?.delete(listener)\n  }\n\n  const $onAny = (listener: AnyChangeListener, { immediate = false }: ListenerOptions = {}): Unsubscribe => {\n    anyListeners.add(listener)\n    if (immediate) walkLeaves(reactive, \"\", (dotKey, value) => listener(dotKey, value))\n    return () => anyListeners.delete(listener)\n  }\n\n  const $effect = (run: () => void, { deep = false, alsoWakenBy }: EffectOptions = {}): Unsubscribe => {\n    // a notify landing while this effect runs (an item's render writing to\n    // the store, waking the very effect that is rendering it) must not\n    // re-enter mid-run - the half-done run would race its own repeat over\n    // shared state, which is how :each once tripled its rows. It marks the\n    // run dirty instead, and repeats *after* it finishes, against settled\n    // state, until clean. Still fully synchronous: everything happens before\n    // the triggering assignment returns\n    let running = false\n    let dirty = false\n    const effect: Effect = {\n      deps: NO_DEPS as Set<string>,\n      reindex: new Set(),\n      deep,\n      order: effectsCreated++,\n      run: () => {\n        if (running) {\n          dirty = true\n          return\n        }\n        running = true\n        try {\n          let cycles = 0\n          do {\n            dirty = false\n            const deps = new Set<string>()\n            trackerStack.push(deps)\n            try {\n              run()\n            } finally {\n              trackerStack.pop()\n              effect.deps = deps\n            }\n          } while (dirty && ++cycles < 100)\n          // an effect that keeps writing its own dependencies used to die by\n          // stack overflow; now it is cut off and named\n          if (dirty) console.error(\"jq79: an effect re-woke itself 100 times in a row (it writes what it reads); giving up on it settling\")\n        } finally {\n          running = false\n          // the settled deps are the only ones worth indexing: the repeats of\n          // a dirty run overwrite each other, and a notify that lands mid-run\n          // is queued rather than dispatched, so nothing reads the index in\n          // between. In `finally` so a run that throws still leaves the index\n          // matching the deps the run did commit\n          effect.reindex.forEach(sync => sync(effect.deps))\n        }\n      },\n    }\n    effects.add(effect)\n    const stopIndexing = indexEffect(effect)\n    const forget = () => {\n      effects.delete(effect)\n      stopIndexing()\n    }\n    // the shared case is rare (only slot content asks for it) and this\n    // function is on the stack for as long as whatever it renders - a\n    // component that renders itself stacks 200 of these - so it keeps the\n    // shape it had, and the extra bookkeeping lives in its own frame\n    if (alsoWakenBy?.length) return attachAndRun(effect, alsoWakenBy, forget)\n    effect.run()\n    return forget\n  }\n\n  // attached before the first run, so a store that notifies during it (a setup\n  // script's write, a prop sync) reaches this effect like any other\n  const attachAndRun = (effect: Effect, alsoWakenBy: Record<string, any>[], forget: Unsubscribe): Unsubscribe => {\n    const detach = alsoWakenBy.map(store => store?.[ATTACH]?.(effect)).filter(Boolean) as Unsubscribe[]\n    effect.run()\n    return () => {\n      forget()\n      detach.forEach(drop => drop())\n    }\n  }\n\n  const $__attach = (effect: Effect): Unsubscribe => {\n    effects.add(effect)\n    const stopIndexing = indexEffect(effect)\n    return () => {\n      effects.delete(effect)\n      stopIndexing()\n    }\n  }\n\n  const $dispose = () => {\n    bridges.forEach(({ unsubscribe }) => unsubscribe())\n    bridges.clear()\n  }\n\n  storeApi.$on = $on\n  storeApi.$onAny = $onAny\n  storeApi.$effect = $effect\n  storeApi.$dispose = $dispose\n  storeApi[ATTACH] = $__attach\n\n  return reactive\n}\n// groups the disposers of every $effect created for one rendered subtree\n// (an :if branch, an :each item, ...) so the whole subtree's bindings can be\n// torn down in one call when that subtree is replaced/removed. `scope.$effect`\n// resolves through the prototype chain up to the root store no matter how\n// many nested :each scopes sit in between (see renderEach's itemScope)\nexport type EffectScope = {\n  effect: (run: () => void) => void\n  // registers an arbitrary cleanup (e.g. destroying a nested component) to\n  // run when this subtree is torn down\n  onDispose: (fn: Unsubscribe) => void\n  // re-runs every effect registered on this scope, nested scopes excluded:\n  // how :each tells a reused, repositioned entry's dep-less bindings (the\n  // `{{ $index }}`-only case) about their move. Deps stay as they were -\n  // callers run it untracked\n  refresh: () => void\n  dispose: () => void\n}\n\n// `deep` marks every effect this scope creates as forwarding a value wholesale\n// rather than reading into it - the prop-sync scope, and nothing else so far.\n// See the `deep` flag on $effect\nexport const createEffectScope = (scope: Record<string, any>, deep = false): EffectScope => {\n  const disposers: Unsubscribe[] = []\n  const runs: (() => void)[] = []\n  // whatever the scope was handed (slot content is the only thing that sets\n  // it today): the stores this scope's effects belong to besides their own.\n  // Left undefined when there are none, which is $effect's fast path\n  const alsoWakenBy: Record<string, any>[] | undefined = (scope as any)[ALSO_WAKEN_BY]\n  return {\n    effect: run => {\n      disposers.push(scope.$effect(run, { deep, alsoWakenBy }))\n      runs.push(run)\n    },\n    onDispose: fn => { disposers.push(fn) },\n    refresh: () => { runs.forEach(run => run()) },\n    dispose: () => {\n      disposers.splice(0).forEach(dispose => dispose())\n      runs.length = 0\n    },\n  }\n}\n","// ---------------------------------------------------------------------------\n// :setup script transform\n//\n// setup scripts are written like Svelte components:\n//\n//   let firstName = null\n//   $: fullName = `${firstName} ${lastName}`\n//   fetchUser().then(user => { firstName = user.firstName })\n//\n// and are executed inside `with ($scope)` against the component's reactive\n// store, so plain assignments (even from async callbacks) go through the\n// proxy's set trap and re-render whatever depends on them. To make that work\n// the source is lightly rewritten - no full JS parser, just a scanner that is\n// string/comment-aware and only touches code at brace/paren depth 0:\n// - `let/var/const x = ...` at the top level loses its keyword, becoming a\n//   scope assignment (the name is pre-declared on the store so the `with`\n//   lookup resolves it)\n// - `$: x = expr` becomes `$__effect(() => { x = expr })`, re-running when a\n//   dependency read inside expr changes ($__effect is deliberately NOT a\n//   property of the scope, so `with` falls through to the function parameter)\n// ---------------------------------------------------------------------------\n\ntype SetupTransform = { vars: string[]; code: string }\n\n// a declaration whose target is an identifier (`let x`), an object pattern\n// (`let { a }`, space optional) or an array pattern (`let [x]`)\nconst DECLARATION_START_RE = /(?:let|var|const)(?:\\s+(?=[A-Za-z_$])|\\s*(?=[{[]))/y\nconst REACTIVE_LABEL_RE = /\\$:\\s*/y\nconst IMPORT_CALL_RE = /import(?=\\s*\\()/y\nconst REACTIVE_ASSIGN_RE = /\\$:\\s*([A-Za-z_$][\\w$]*)\\s*=(?!=)/y\n\nconst skipString = (src: string, start: number): number => {\n  const quote = src[start]\n  let i = start + 1\n  while (i < src.length) {\n    if (src[i] === \"\\\\\") { i += 2; continue }\n    if (src[i] === quote) return i + 1\n    i++\n  }\n  return src.length\n}\n\nconst skipLineComment = (src: string, start: number): number => {\n  const end = src.indexOf(\"\\n\", start)\n  return end === -1 ? src.length : end\n}\n\nconst skipBlockComment = (src: string, start: number): number => {\n  const end = src.indexOf(\"*/\", start + 2)\n  return end === -1 ? src.length : end + 2\n}\n\n// index of the next thing that isn't whitespace or a comment\nconst skipToToken = (src: string, start: number): number => {\n  let i = start\n  while (i < src.length) {\n    if (/\\s/.test(src[i])) { i++; continue }\n    if (src[i] === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (src[i] === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    break\n  }\n  return i\n}\n\n// ---------------------------------------------------------------------------\n// regex literals. The scanners walk the source counting bracket depth, and a\n// regex walked as if it were code poisons that count: `split(/\\//)` puts two\n// slashes side by side (a line comment, as far as a scanner knows) and the\n// `)` after them is skipped uncounted; `/[(]/` inflates the depth for good.\n// So a `/` that opens a regex is consumed whole - and whether it opens one is\n// the classic lexer call, made the way every tokenizer makes it: by what came\n// before. Division needs a completed expression on its left; everywhere else\n// a `/` can only be a regex.\n// ---------------------------------------------------------------------------\n\n// reserved words a regex can follow. Reserved only - `of` is not (`const of\n// = 4; of / 2` is legal division), so `for (x of /re/)` stays unrescued\n// rather than risking real code\nconst REGEX_AFTER_WORD = new Set([\n  \"return\", \"typeof\", \"case\", \"in\", \"instanceof\", \"new\", \"delete\", \"void\", \"do\", \"else\", \"yield\", \"await\",\n])\n\n// whether a `/` at `at` opens a regex literal rather than a division: looks\n// backward past whitespace and block comments for the last meaningful thing.\n// A completed expression - identifier, number, closing quote or bracket,\n// postfix ++/-- - takes division; a reserved word or any other punctuator\n// admits a regex. Only consulted for the rare `/` that is neither `//` nor\n// `/*`, so the scanners pay nothing on the common path\nconst regexAllowed = (src: string, at: number): boolean => {\n  let i = at - 1\n  while (i >= 0) {\n    const ch = src[i]\n    if (/\\s/.test(ch)) { i--; continue }\n    if (ch === \"/\" && src[i - 1] === \"*\") {\n      const open = src.lastIndexOf(\"/*\", i - 2)\n      if (open === -1) return true // an unopened comment tail: malformed input\n      i = open - 1\n      continue\n    }\n    break\n  }\n  if (i < 0) return true // the start of the source starts an expression\n  const ch = src[i]\n  if (/[\\w$]/.test(ch)) {\n    let start = i\n    while (start > 0 && /[\\w$]/.test(src[start - 1])) start--\n    return REGEX_AFTER_WORD.has(src.slice(start, i + 1))\n  }\n  if ((ch === \"+\" || ch === \"-\") && src[i - 1] === ch) return false // postfix ++/--\n  return !\")]}\\\"'`.\".includes(ch)\n}\n\n// consumes a regex literal (with its flags): backslash escapes, and character\n// classes, where an unescaped `/` doesn't close the literal (`/[/]/` is one\n// regex). A literal can't contain an unescaped newline, so hitting one means\n// the classification was wrong or the input malformed - stop there, bounding\n// any damage to a single line\nconst skipRegex = (src: string, start: number): number => {\n  let i = start + 1\n  let inClass = false\n  while (i < src.length) {\n    const ch = src[i]\n    if (ch === \"\\\\\") { i += 2; continue }\n    if (ch === \"\\n\") return i\n    if (ch === \"[\") inClass = true\n    else if (ch === \"]\") inClass = false\n    else if (ch === \"/\" && !inClass) {\n      i++\n      while (i < src.length && /[a-z]/i.test(src[i])) i++ // flags\n      return i\n    }\n    i++\n  }\n  return src.length\n}\n\n// tokens that can't *start* a statement, so a line beginning with one is\n// continuing the previous expression rather than opening a new statement -\n// the same call JS's automatic semicolon insertion makes. Unary-only forms\n// (!, ~, ++, --) are deliberately absent: those do start a statement, and JS\n// inserts the semicolon before them\nconst CONTINUATION_RE = /^(\\?\\.|\\?\\?|&&|\\|\\||\\*\\*|[.,+\\-*/%&|^<>=?:([])/\n\n// the last meaningful character before `at`: walks back past whitespace and\n// block comments, the way regexAllowed does. A line comment can't be skipped\n// from behind (its start is only findable forwards), so a line ending in one\n// reports the comment's text instead - callers treat that as \"not the char I\n// was looking for\", which degrades to ending the statement, exactly as\n// before this helper existed\nconst lastMeaningfulBefore = (src: string, at: number): string => {\n  let i = at - 1\n  while (i >= 0) {\n    const ch = src[i]\n    if (/\\s/.test(ch)) { i--; continue }\n    if (ch === \"/\" && src[i - 1] === \"*\") {\n      const open = src.lastIndexOf(\"/*\", i - 2)\n      if (open === -1) return \"\"\n      i = open - 1\n      continue\n    }\n    return ch\n  }\n  return \"\"\n}\n\n// end of a statement starting at `start`: the first `;` or line break that\n// isn't inside a string/comment or unbalanced brackets. A line break only\n// ends the statement if the next line can't continue it, so leading-dot\n// method chains and multi-line operator chains stay in one piece:\n//\n//   $: total = items\n//     .filter(item => item.active)      <- still the same statement\n//     .length\n//\n// ...and only if the current line *can* end it: a line whose last meaningful\n// character is `,` or `=` left its expression incomplete (a multi-line\n// declarator list writes exactly this), so the statement continues - the\n// same ASI call as the leading-token check, made from the other side\nconst findStatementEnd = (src: string, start: number): number => {\n  let depth = 0\n  let i = start\n  while (i < src.length) {\n    const ch = src[i]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { i = skipString(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (ch === \"/\" && regexAllowed(src, i)) { i = skipRegex(src, i); continue }\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch)) depth--\n    else if (depth <= 0 && ch === \";\") return i\n    else if (depth <= 0 && ch === \"\\n\") {\n      const next = skipToToken(src, i + 1)\n      const continues =\n        next < src.length &&\n        (CONTINUATION_RE.test(src.slice(next, next + 2)) || [\",\", \"=\"].includes(lastMeaningfulBefore(src, i)))\n      if (!continues) return i\n      i = next\n      continue\n    }\n    i++\n  }\n  return src.length\n}\n\n// ---------------------------------------------------------------------------\n// top-level declarations. `let x = 1` loses its keyword and becomes a scope\n// assignment (x pre-declared on the store). A destructuring declarator\n// becomes an *assignment pattern*: inside `with`, `({ a, b } = obj)` writes\n// every binding through the reactive proxy - which is what makes it reactive.\n// The parens keep the `{` from opening a block, and a leading `;` keeps the\n// `(` from gluing onto the previous line as a call. Multi-declarator\n// statements (`let a = 1, b = 2`) register every binding, not just the first.\n// These lean on the pattern helpers defined with the props signature below\n// (splitTopLevel, indexOfTopLevel, defaultAssignIndex); the scanner only\n// runs long after the module evaluates, so the order is cosmetic\n// ---------------------------------------------------------------------------\n\ntype Declarator = { raw: string; codeEnd: number }\n\n// splits a declarator list at top-level commas, keeping each segment's raw\n// text (layout and comments included) and where its last meaningful token\n// ends - the spot a closing paren must go, so a trailing comment can't\n// swallow it\nconst splitDeclarators = (src: string): Declarator[] => {\n  const parts: Declarator[] = []\n  let depth = 0\n  let start = 0\n  let lastEnd = 0\n  const flush = (end: number) => {\n    parts.push({ raw: src.slice(start, end), codeEnd: Math.max(0, lastEnd - start) })\n    start = end + 1\n    lastEnd = start\n  }\n  let i = 0\n  while (i < src.length) {\n    const ch = src[i]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { i = skipString(src, i); lastEnd = i; continue }\n    if (ch === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (ch === \"/\" && regexAllowed(src, i)) { i = skipRegex(src, i); lastEnd = i; continue }\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch)) depth--\n    else if (ch === \",\" && depth <= 0) { flush(i); i++; continue }\n    if (!/\\s/.test(ch)) lastEnd = i + 1\n    i++\n  }\n  flush(src.length)\n  return parts\n}\n\n// the *binding* names a destructuring pattern declares - unlike\n// parsePropsPattern, which answers \"which props\" (the keys), this answers\n// \"which variables\": `{ a: x }` binds x, `{ a: { b } }` binds b,\n// `[x, ...rest]` binds x and rest. Defaults are stripped; what remains is a\n// nested pattern (recurse) or the bound identifier\nconst patternBindings = (src: string): string[] => {\n  const pattern = src.trim()\n  if (!pattern.startsWith(\"{\") && !pattern.startsWith(\"[\")) {\n    return IDENTIFIER_RE.test(pattern) ? [pattern] : []\n  }\n  const names: string[] = []\n  for (let part of splitTopLevel(pattern.slice(1, patternCloseIndex(pattern)))) {\n    if (part.startsWith(\"...\")) part = part.slice(3).trim()\n    const assign = defaultAssignIndex(part)\n    if (assign !== -1) part = part.slice(0, assign).trim()\n    if (pattern.startsWith(\"{\")) {\n      const colon = indexOfTopLevel(part, \":\")\n      if (colon !== -1) {\n        names.push(...patternBindings(part.slice(colon + 1)))\n        continue\n      }\n    }\n    names.push(...patternBindings(part))\n  }\n  return names\n}\n\n// one `let/var/const` declarator list, rewritten to scope assignments.\n// Each segment's initializer is re-scanned so an `import()` inside it is\n// rewritten like anywhere else - nothing else can match in there, since a\n// nested top-level declaration inside a declarator is a SyntaxError in JS\nconst rewriteDeclarators = (src: string): SetupTransform => {\n  const vars: string[] = []\n  const rewritten = splitDeclarators(src).map(({ raw, codeEnd }) => {\n    const lead = raw.match(/^\\s*/)![0]\n    if (codeEnd <= lead.length) return { text: raw, empty: true }\n    const body = raw.slice(lead.length, codeEnd)\n    const tail = raw.slice(codeEnd)\n    const assign = defaultAssignIndex(body)\n    const target = (assign === -1 ? body : body.slice(0, assign)).trim()\n    const isPattern = body[0] === \"{\" || body[0] === \"[\"\n    if (isPattern) vars.push(...patternBindings(target))\n    else if (IDENTIFIER_RE.test(target)) vars.push(target)\n    const code = transformSetupScript(body).code\n    return { text: `${lead}${isPattern ? `(${code})` : code}${tail}`, empty: false }\n  })\n\n  // a trailing comment-only segment (`let a = 1, // note` cut at its line\n  // end) is re-attached without its comma, so the output stays a statement\n  const tail: string[] = []\n  while (rewritten.length && rewritten[rewritten.length - 1].empty) tail.unshift(rewritten.pop()!.text)\n  let code = rewritten.map(part => part.text).join(\",\") + tail.join(\"\")\n  if (code.trimStart().startsWith(\"(\")) code = `;${code}`\n  return { vars, code }\n}\n\nexport const transformSetupScript = (src: string): SetupTransform => {\n  const vars: string[] = []\n  let out = \"\"\n  let i = 0\n  let depth = 0\n  let atStatementStart = true\n\n  while (i < src.length) {\n    const ch = src[i]\n    const next = src[i + 1]\n\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") {\n      const end = skipString(src, i)\n      out += src.slice(i, end)\n      i = end\n      atStatementStart = false\n      continue\n    }\n    if (ch === \"/\" && (next === \"/\" || next === \"*\")) {\n      const end = next === \"/\" ? skipLineComment(src, i) : skipBlockComment(src, i)\n      out += src.slice(i, end)\n      i = end\n      continue\n    }\n    if (ch === \"/\" && regexAllowed(src, i)) {\n      const end = skipRegex(src, i)\n      out += src.slice(i, end)\n      i = end\n      atStatementStart = false\n      continue\n    }\n\n    // `import(...)` is a keyword form, so it can't be intercepted through the\n    // scope - rewrite the identifier to the injected $__import (which loads\n    // .html URLs as components via Component79.fetch and delegates the rest to\n    // native import). The `(` is left for the scanner so depth stays balanced\n    if (ch === \"i\" && (i === 0 || !/[\\w$.]/.test(src[i - 1]))) {\n      IMPORT_CALL_RE.lastIndex = i\n      if (IMPORT_CALL_RE.test(src)) {\n        out += \"$__import\"\n        i += \"import\".length\n        atStatementStart = false\n        continue\n      }\n    }\n\n    if (depth === 0 && atStatementStart) {\n      DECLARATION_START_RE.lastIndex = i\n      const decl = DECLARATION_START_RE.exec(src)\n      if (decl) {\n        const start = i + decl[0].length\n        const end = findStatementEnd(src, start)\n        const { vars: names, code } = rewriteDeclarators(src.slice(start, end))\n        vars.push(...names)\n        out += code\n        i = end\n        atStatementStart = false\n        continue\n      }\n\n      REACTIVE_LABEL_RE.lastIndex = i\n      const label = REACTIVE_LABEL_RE.exec(src)\n      if (label) {\n        REACTIVE_ASSIGN_RE.lastIndex = i\n        const assign = REACTIVE_ASSIGN_RE.exec(src)\n        if (assign) vars.push(assign[1])\n        const start = i + label[0].length\n        const end = findStatementEnd(src, start)\n        // the body is re-scanned rather than sliced raw, so an `import()`\n        // inside it gets the $__import rewrite like anywhere else. Safe to\n        // recurse: strings/comments/regexes copy through unchanged, and a\n        // depth-0 declaration inside a labeled statement is a SyntaxError\n        // in JS anyway, so nothing else can rewrite\n        out += `$__effect(() => { ${transformSetupScript(src.slice(start, end)).code} });`\n        i = end\n        continue\n      }\n    }\n\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch)) depth = Math.max(0, depth - 1)\n\n    if (ch === \"\\n\" || ch === \";\" || ch === \"}\") atStatementStart = true\n    else if (!/\\s/.test(ch)) atStatementStart = false\n\n    out += ch\n    i++\n  }\n\n  return { vars, code: out }\n}\n\n// ---------------------------------------------------------------------------\n// factory scripts - a <script> whose top level has `export default` runs as a\n// plain lexical module instead of a `with`-scoped setup script: no implicit\n// reactivity, no `$:` labels - standard JS that editors and type-checkers\n// understand. The default export is called with the instance context\n// ({ $data, $effect, $emit, $mounted, $self, $$self }) and a returned object\n// is merged into the reactive store for the template to use.\n// Detection is backwards-safe: `export default` is a SyntaxError inside a\n// setup script, so no previously-working component can change behavior.\n// The same scanner rewrites the module-only syntax into a Function body:\n// - `export default X`      -> `$__exports.default = X`\n// - `import d from \"m\"`     -> `const d = $__default(await $__import(\"m\"))`\n//   (and the other static clause forms), so imports resolve through the same\n//   $__import as setup scripts: bundler map first, then fetch/native import\n// ---------------------------------------------------------------------------\n\nconst EXPORT_DEFAULT_RE = /export\\s+default(?![\\w$])/y\n// clause (default/namespace/named, no quotes or parens) + specifier; the\n// no-clause alternative requires the specifier right away, so dynamic\n// `import(...)` and `import.meta` never match\nconst STATIC_IMPORT_RE = /import\\s*(?:([\\w$\\s,{}*]+?)\\s*from\\s*)?([\"'])([^\"'\\n]+)\\2/y\n\n// splits an import clause on top-level commas: `d, { a, b as c }` keeps the\n// braced group together\nconst splitImportClause = (clause: string): string[] => {\n  const parts: string[] = []\n  let depth = 0\n  let start = 0\n  for (let i = 0; i <= clause.length; i++) {\n    const ch = clause[i]\n    if (ch === \"{\") depth++\n    else if (ch === \"}\") depth--\n    else if (i === clause.length || (ch === \",\" && depth === 0)) {\n      const part = clause.slice(start, i).trim()\n      if (part) parts.push(part)\n      start = i + 1\n    }\n  }\n  return parts\n}\n\n// one static import statement -> const bindings from the awaited module\nconst staticImportToAwait = (clause: string | undefined, spec: string, n: number): string => {\n  const source = `await $__import(${JSON.stringify(spec)})`\n  if (clause === undefined) return source // side-effect import\n  const parts = splitImportClause(clause)\n  const bindings: string[] = []\n  let ref = source\n  if (parts.length > 1) {\n    const tmp = `$__mod${n}`\n    bindings.push(`${tmp} = ${source}`)\n    ref = tmp\n  }\n  for (const part of parts) {\n    if (part.startsWith(\"{\")) bindings.push(`${part.replace(/\\s+as\\s+/g, \": \")} = ${ref}`)\n    else if (part.startsWith(\"*\")) bindings.push(`${part.replace(/^\\*\\s*as\\s+/, \"\")} = ${ref}`)\n    else bindings.push(`${part} = $__default(${ref})`)\n  }\n  return `const ${bindings.join(\", \")}`\n}\n\n// ---------------------------------------------------------------------------\n// the component's prop signature\n//\n// A component declares the props it takes as a destructuring pattern, in the\n// place each script mode already puts its inputs: the `:setup` attribute's\n// value, or the factory's *first* parameter (the ctx moved to the second).\n// Position is fixed, so the signature is read straight from the source string -\n// no parser, no execution - and the runtime can seed the defaults on the store\n// before the first render, which is what makes them reach the template even in\n// factory mode (where JS would only apply them inside the function body).\n//\n//   <script :setup=\"{ label = 'Total', step = 1 }\">\n//   export default ({ label = \"Total\" }, { $data }) => {}\n//\n// An object pattern *is* the declaration; anything else (`_`, a plain\n// identifier, no attribute at all) declares nothing and stays permissive.\n// ---------------------------------------------------------------------------\n\n// `as` is the local name the pattern binds the key to, when it isn't the key\n// itself (`{ item: row }`). A prop signature has no use for it - what the\n// store holds is the key - but the slot binder (`:slot=\"{ item: row }\"`) is\n// the same pattern read for the other half: which names the content uses\nexport type PropDecl = { name: string; default?: string; as?: string }\n\nconst IDENTIFIER_RE = /^[A-Za-z_$][\\w$]*$/\n\n// index of the bracket that closes the one opening at src[0], skipping\n// strings, comments and regex literals; src.length when unbalanced\nconst patternCloseIndex = (src: string): number => {\n  let depth = 0\n  let i = 0\n  while (i < src.length) {\n    const ch = src[i]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { i = skipString(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (ch === \"/\" && regexAllowed(src, i)) { i = skipRegex(src, i); continue }\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch) && --depth === 0) return i\n    i++\n  }\n  return src.length\n}\n\n// index of the first `ch` at bracket depth 0, skipping strings and comments\nconst indexOfTopLevel = (src: string, ch: string): number => {\n  let depth = 0\n  let i = 0\n  while (i < src.length) {\n    const c = src[i]\n    if (c === \"'\" || c === '\"' || c === \"`\") { i = skipString(src, i); continue }\n    if (c === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (c === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (c === \"/\" && c !== ch && regexAllowed(src, i)) { i = skipRegex(src, i); continue }\n    if (\"([{\".includes(c)) depth++\n    else if (\")]}\".includes(c)) depth--\n    else if (depth === 0 && c === ch) return i\n    i++\n  }\n  return -1\n}\n\nconst splitTopLevel = (src: string): string[] => {\n  const parts: string[] = []\n  let depth = 0\n  let start = 0\n  let i = 0\n  while (i <= src.length) {\n    const ch = src[i]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { i = skipString(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (ch === \"/\" && regexAllowed(src, i)) { i = skipRegex(src, i); continue }\n    if (ch !== undefined && \"([{\".includes(ch)) depth++\n    else if (ch !== undefined && \")]}\".includes(ch)) depth--\n    else if (i === src.length || (ch === \",\" && depth === 0)) {\n      const part = src.slice(start, i).trim()\n      if (part) parts.push(part)\n      start = i + 1\n    }\n    i++\n  }\n  return parts\n}\n\n// the `=` that opens a default value: the first one at depth 0 that isn't part\n// of `==`/`===` or an arrow's `=>` (so `{ format = a => a }` keeps its default)\nconst defaultAssignIndex = (src: string): number => {\n  let from = 0\n  while (from < src.length) {\n    const at = indexOfTopLevel(src.slice(from), \"=\")\n    if (at === -1) return -1\n    const i = from + at\n    if (src[i + 1] !== \"=\" && src[i + 1] !== \">\" && src[i - 1] !== \"=\" && src[i - 1] !== \"!\") return i\n    from = i + 1\n  }\n  return -1\n}\n\n// a destructuring pattern -> the props it declares. null means \"no signature\":\n// the pattern isn't an object one (`_`, `props`, nothing at all), so the\n// component declares nothing and keeps the permissive, undeclared behavior.\n// `{}` parses to [] - a closed signature that declares zero props\nexport const parsePropsPattern = (pattern: string | undefined): PropDecl[] | null => {\n  const src = (pattern ?? \"\").trim()\n  if (!src.startsWith(\"{\")) return null\n\n  // to the `}` that closes the pattern, so a parameter's own default value\n  // (`({ label } = {})`) is left out of it\n  const close = patternCloseIndex(src)\n  if (close >= src.length) return null // unbalanced: not a pattern we can read\n\n  const props: PropDecl[] = []\n  for (const part of splitTopLevel(src.slice(1, close))) {\n    if (part.startsWith(\"...\")) continue // a rest element names no prop\n    const assign = defaultAssignIndex(part)\n    const named = assign === -1 ? part : part.slice(0, assign)\n    const fallback = assign === -1 ? undefined : part.slice(assign + 1).trim()\n    // `{ user: { id } }` and `{ user: renamed }` both declare `user`: what the\n    // store holds is the key, whatever the pattern binds it to\n    const colon = indexOfTopLevel(named, \":\")\n    const name = (colon === -1 ? named : named.slice(0, colon)).trim()\n    if (!IDENTIFIER_RE.test(name)) continue\n    const decl: PropDecl = { name }\n    if (fallback !== undefined) decl.default = fallback\n    // only a plain rename is kept: `{ user: { id } }` binds no single name, so\n    // there is nothing to record - the prop is still declared under its key\n    const local = colon === -1 ? \"\" : named.slice(colon + 1).trim()\n    if (IDENTIFIER_RE.test(local)) decl.as = local\n    props.push(decl)\n  }\n  return props\n}\n\n// index just past a top-level `export default`, or -1\nconst findExportDefault = (src: string): number => {\n  let i = 0\n  let depth = 0\n  let atStatementStart = true\n  while (i < src.length) {\n    const ch = src[i]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { i = skipString(src, i); atStatementStart = false; continue }\n    if (ch === \"/\" && src[i + 1] === \"/\") { i = skipLineComment(src, i); continue }\n    if (ch === \"/\" && src[i + 1] === \"*\") { i = skipBlockComment(src, i); continue }\n    if (ch === \"/\" && regexAllowed(src, i)) { i = skipRegex(src, i); atStatementStart = false; continue }\n\n    if (ch === \"e\" && depth === 0 && atStatementStart && (i === 0 || !/[\\w$.]/.test(src[i - 1]))) {\n      EXPORT_DEFAULT_RE.lastIndex = i\n      const found = EXPORT_DEFAULT_RE.exec(src)\n      if (found) return i + found[0].length\n    }\n\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch)) depth = Math.max(0, depth - 1)\n    if (ch === \"\\n\" || ch === \";\" || ch === \"}\") atStatementStart = true\n    else if (!/\\s/.test(ch)) atStatementStart = false\n    i++\n  }\n  return -1\n}\n\nconst ASYNC_RE = /^async(?![\\w$])/\nconst FUNCTION_RE = /^function(?![\\w$])\\s*\\*?\\s*[A-Za-z_$][\\w$]*|^function(?![\\w$])\\s*\\*?/\n\n// source text of the exported function's first parameter, or null when there\n// is no parameter list to read (`export default Factory`, `export default\n// props => ...`, an exported object) - all of which declare nothing\nconst firstParameterSource = (src: string): string | null => {\n  const start = findExportDefault(src)\n  if (start === -1) return null\n\n  let i = skipToToken(src, start)\n  const rest = src.slice(i)\n  if (ASYNC_RE.test(rest)) i = skipToToken(src, i + \"async\".length)\n  const fn = FUNCTION_RE.exec(src.slice(i))\n  if (fn) i = skipToToken(src, i + fn[0].length)\n  if (src[i] !== \"(\") return null\n\n  // the parameter list runs to the `)` that closes this `(`\n  let depth = 0\n  let end = i\n  while (end < src.length) {\n    const ch = src[end]\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") { end = skipString(src, end); continue }\n    if (ch === \"/\" && src[end + 1] === \"/\") { end = skipLineComment(src, end); continue }\n    if (ch === \"/\" && src[end + 1] === \"*\") { end = skipBlockComment(src, end); continue }\n    if (ch === \"/\" && regexAllowed(src, end)) { end = skipRegex(src, end); continue }\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch) && --depth === 0) break\n    end++\n  }\n  return splitTopLevel(src.slice(i + 1, end))[0] ?? \"\"\n}\n\n// the props declared by a factory script's first parameter. Throws the\n// migration error when it finds the pre-0.4 signature there - the ctx used to\n// be the first parameter, and the change is silent otherwise ($data would just\n// come back undefined). `$` is what tells them apart: what carries one comes\n// from the library, what doesn't comes from the parent, everywhere in jq79\nexport const parseFactoryProps = (src: string): PropDecl[] | null => {\n  const first = firstParameterSource(src)\n  if (first === null) return null\n  const props = parsePropsPattern(first)\n  const ctxName = props?.find(prop => prop.name.startsWith(\"$\"))?.name\n  if (ctxName) {\n    throw new Error(\n      `jq79: the factory signature is (props, ctx), so \\`${ctxName}\\` can't be destructured from the first parameter. ` +\n      `Write \\`export default (props, { ${ctxName} }) => …\\`, or \\`_\\` in place of props if the component takes none.`\n    )\n  }\n  return props\n}\n\n// rewrites a factory script into a Function body, or returns null when the\n// script has no top-level `export default` (i.e. it's a regular setup script)\nexport const transformFactoryScript = (src: string): string | null => {\n  let out = \"\"\n  let i = 0\n  let depth = 0\n  let atStatementStart = true\n  let isFactory = false\n  let modCount = 0\n\n  while (i < src.length) {\n    const ch = src[i]\n    const next = src[i + 1]\n    const atWordBoundary = i === 0 || !/[\\w$.]/.test(src[i - 1])\n\n    if (ch === \"'\" || ch === '\"' || ch === \"`\") {\n      const end = skipString(src, i)\n      out += src.slice(i, end)\n      i = end\n      atStatementStart = false\n      continue\n    }\n    if (ch === \"/\" && (next === \"/\" || next === \"*\")) {\n      const end = next === \"/\" ? skipLineComment(src, i) : skipBlockComment(src, i)\n      out += src.slice(i, end)\n      i = end\n      continue\n    }\n    if (ch === \"/\" && regexAllowed(src, i)) {\n      const end = skipRegex(src, i)\n      out += src.slice(i, end)\n      i = end\n      atStatementStart = false\n      continue\n    }\n\n    if (ch === \"i\" && atWordBoundary) {\n      // dynamic import() -> $__import, same rewrite as setup scripts\n      IMPORT_CALL_RE.lastIndex = i\n      if (IMPORT_CALL_RE.test(src)) {\n        out += \"$__import\"\n        i += \"import\".length\n        atStatementStart = false\n        continue\n      }\n      if (depth === 0 && atStatementStart) {\n        STATIC_IMPORT_RE.lastIndex = i\n        const staticImport = STATIC_IMPORT_RE.exec(src)\n        if (staticImport) {\n          out += staticImportToAwait(staticImport[1], staticImport[3], modCount++)\n          i += staticImport[0].length\n          atStatementStart = false\n          continue\n        }\n      }\n    }\n\n    if (ch === \"e\" && atWordBoundary && depth === 0 && atStatementStart) {\n      EXPORT_DEFAULT_RE.lastIndex = i\n      const exportDefault = EXPORT_DEFAULT_RE.exec(src)\n      if (exportDefault) {\n        isFactory = true\n        out += \"$__exports.default =\"\n        i += exportDefault[0].length\n        atStatementStart = false\n        continue\n      }\n    }\n\n    if (\"([{\".includes(ch)) depth++\n    else if (\")]}\".includes(ch)) depth = Math.max(0, depth - 1)\n\n    if (ch === \"\\n\" || ch === \";\" || ch === \"}\") atStatementStart = true\n    else if (!/\\s/.test(ch)) atStatementStart = false\n\n    out += ch\n    i++\n  }\n\n  return isFactory ? out : null\n}\n\n"],"mappings":"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","names":["jq79_exports","__export","$","$$","$create","$reactive","$toRaw","Component79","PendingComponent79","enableHotReload","hotUpdate","parseComponent","renderComponent","__toCommonJS","$","selectorOrEl","selector","$$","$create","tag","attrs","el","name","value","child","ALLOWED_TAGS","ALLOWED_ATTR","SAFE_URL_PROTOCOLS","isSafeUrl","url","DEFAULT_PORTS","compileHostPattern","pattern","match","host","port","labels","label","allowedHosts","patterns","compiled","p","consultAllowUrl","allowUrl","attr","MAX_SANITIZE_DEPTH","appendSanitizedChildren","source","target","depth","sanitizedChild","sanitizeNode","node","clean","allowedForTag","allowedGlobal","sanitizeHTML","html","options","template","container","getByPath","obj","dotKey","acc","key","isPlainData","value","proto","walkLeaves","path","visit","KEYS_SEGMENT","keysPath","createTrieNode","parent","segment","isEmptyNode","node","RAW","$toRaw","raw","STORE","isStore","trackerStack","untracked","fn","effectsCreated","NO_DEPS","ATTACH","ALSO_WAKEN_BY","$reactive","data","exactListeners","anyListeners","effects","proxies","storeApi","depTrie","insertDep","dep","effect","children","child","removeDep","current","nodeAt","effectsFor","matched","sweep","from","pending","next","segments","depth","bridges","indexable","deps","redundant","dot","kept","indexEffect","soleDep","soleNode","indexed","lastTracked","placed","place","unplaceStale","unplaceAll","sync","tracked","unchanged","wakeExactly","runMatched","notifyKeys","ordered","sorted","i","a","b","notify","isNewKey","listener","replaceable","previous","keyCount","container","GIVE_UP","whatChanged","before","after","span","changed","index","keys","notifyReplaced","notified","collectExact","isWrappable","wrap","lengthKey","bridge","store","unbridge","cached","tombstones","proxy","target","receiver","stored","had","deleted","reactive","$on","immediate","$onAny","$effect","run","deep","alsoWakenBy","running","dirty","cycles","stopIndexing","forget","attachAndRun","detach","drop","$__attach","$dispose","unsubscribe","createEffectScope","scope","disposers","runs","dispose","DECLARATION_START_RE","REACTIVE_LABEL_RE","IMPORT_CALL_RE","REACTIVE_ASSIGN_RE","skipString","src","start","quote","i","skipLineComment","end","skipBlockComment","skipToToken","REGEX_AFTER_WORD","regexAllowed","at","ch","open","skipRegex","inClass","CONTINUATION_RE","lastMeaningfulBefore","findStatementEnd","depth","next","splitDeclarators","parts","lastEnd","flush","patternBindings","pattern","IDENTIFIER_RE","names","part","splitTopLevel","patternCloseIndex","assign","defaultAssignIndex","colon","indexOfTopLevel","rewriteDeclarators","vars","rewritten","raw","codeEnd","lead","body","tail","target","isPattern","code","transformSetupScript","out","atStatementStart","decl","label","EXPORT_DEFAULT_RE","STATIC_IMPORT_RE","splitImportClause","clause","staticImportToAwait","spec","source","bindings","ref","tmp","c","from","parsePropsPattern","close","props","named","fallback","name","local","findExportDefault","found","ASYNC_RE","FUNCTION_RE","firstParameterSource","rest","fn","parseFactoryProps","first","ctxName","prop","transformFactoryScript","isFactory","modCount","atWordBoundary","staticImport","exportDefault","VERSION","elementAttrs","el","attr","elementToAST","attrs","component","COMPONENT_TAG_ATTR","node","text","compiled","compileExpr","expr","params","key","fn","MISSING_NAME_RE","MAX_PENDING_REPORTS","pendingReports","reportedExprErrors","pendingScripts","flushScheduled","reportedFailedExprs","flushExprReports","name","scope","scheduleExprReportFlush","trackScript","settled","release","reportFailedExpr","error","message","reportExprError","match","runExpr","extras","evalExpr","evalHandler","interpolate","template","_","CONTROL_ATTRS","isControlAttr","EACH_PATTERN","bindEvent","modifiers","mods","event","handler","wireTagEvent","instance","listener","untracked","kebabToCamel","c","camelToKebab","boundsOf","removeRange","first","last","next","removeRuns","runs","run","range","contiguousRuns","ordered","isDead","entry","moveRangeAfter","prev","ref","scanComponentKey","tag","normalized","obj","tagMemo","memoBase","openRenderPass","base","outer","closeRenderPass","findComponentKey","componentsInScope","names","unresolvedComponent","MAX_NESTING_DEPTH","nestingDepth","SLOTS","isSlotTag","slotName","suffix","slotAttrOf","slotAttrName","isMeaningful","partitionSlots","contents","loose","child","hasLoose","bindSlotProps","binder","props","parsePropsPattern","as","fallback","local","value","misplacedSlotContent","buildSlots","slots","content","makeSlotRenderer","parentScope","slotScope","fx","shadow","inherited","ALSO_WAKEN_BY","contentFx","createEffectScope","renderNodes","renderSlot","wrapper","anchor","endAnchor","render","SCOPE_ATTR","renderNestedComponent","models","events","sources","hasSpread","modelAttr","modelProp","assignment","unassignable","prop","resolveProps","out","current","currentDef","childFx","reported","reportUnresolved","UNFILLED_PROPS","nextDef","Component79","warned","rawName","declared","declaredPropSet","warnUndeclared","seed","pickDeclared","holder","syncFx","written","nextKeys","createWithScope","source","target","classNames","on","normalizeAllowUrl","policy","url","allowedHosts","BOOLEAN_ATTRS","applyAttr","boolean","renderNode","outerScope","withExpr","componentKey","PENDING_SCRIPTS","mayUpgrade","upgraded","replacement","bindExpr","boundKeys","bound","classExpr","classToggles","staticClasses","textExpr","htmlExpr","allowedExpr","options","sanitizeHTML","valueExpr","renderConditional","branches","activeBranch","branchFx","branch","rendered","defineScopeVar","isPlainObject","proto","mentionsAny","identifierIn","IDENTIFIER_CHAR","at","before","after","renderEach","itemName","atName","listExpr","keyExpr","_each","_key","itemAttrs","itemNode","positionalNames","readsPosition","entries","warnedDuplicates","pass","list","pairs","item","index","previous","bucket","seen","moved","nextEntries","itemScope","existing","itemFx","dead","prevNode","nodes","into","fragment","textNode","nextBranch","candidate","elseif","elseNode","renderComponent","data","VOID_ELEMENTS","SELF_CLOSING_RE","RAW_BLOCK_RE","expandSelfClosingTags","src","chunk","i","OPEN_TAG_RE","ATTR_SPREAD_RE","expandPropsSpread","_match","n","rewritten","whole","space","ATTR_NAME_RE","CLOSE_SLOT_RE","SLOT_TAG_RE","kebabTagName","COMPONENT_TAG_RE","TRAILING_SLASH_RE","stampComponentTag","stamp","slash","expandNameCase","scopeHash","hash","stampScope","scopeSelector","selectorText","part","selector","pseudoAt","pseudoElement","scopeRules","rules","rule","scopeCss","css","sheet","COMPONENT_NAME_RE","parseComponentString","prepared","root","own","declarations","parts","componentPartsFrom","siblings","elements","hashSource","scripts","styles","block","style","isScoped","importResource","fetchComponent","RESOLVABLE_SPECIFIER_RE","resolveSpecifier","spec","filename","sourceUrlComment","headStyle","styleRegistry","acquireStyle","releaseStyle","runSetupScript","code","effect","instanceHelpers","importer","helpers","SETUP_HELPERS","scriptScope","state","result","declareProps","store","setupSignature","script","pattern","warnUnreadableSignature","signatureWarned","declaredPropNames","parseFactoryProps","undeclaredWarned","said","siblingsInScope","inScope","any","interopDefault","mod","runFactoryScript","$__exports","logError","invoked","merging","invoke","factory","merge","bindings","returned","HOT_FLAG","HOT_RUNTIME","hotRegistry","hotRegister","refs","hotKey","hotUpdate","orphaned","partsFor","rerendered","enableHotReload","STUCK_RENDER_DELAY","warnIfStuck","gates","timer","response","__publicField","sibling","marker","live","parent","PendingComponent79","urls","eventName","siblingScope","raw","unfilled","$reactive","warnedModelUpdate","$emit","payload","resolveMounted","mounted","resolve","endMarker","$$self","found","$self","modules","$import","injected","args","defer","allSync","resolveGate","open","deferred","factoryCode","transformFactoryScript","body","vars","transformSetupScript","pending","settle","templateScope","receiver","$","nextNode","action","onfulfilled","onrejected","onfinally","parseComponent","component","Component79","SETUP_HELPERS","$","$$","$create","$reactive","$toRaw","HOT_FLAG","enableHotReload"]}