kerfjs 5.0.0-beta.3 → 5.0.0-beta.30

package/dist/chunk-BDX3R4OM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/segment.ts"],"names":[],"mappings":"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","file":"chunk-BDX3R4OM.js","sourcesContent":["/**\n * `Segment` — kerf's structured render output.\n *\n * The JSX runtime emits a `SafeHtml` wrapping a `Segment`. Most renders\n * produce a single static segment (just an HTML string), which behaves\n * exactly like a string for backward compatibility. When the tree\n * contains a list (`each()`) or a parent whose children include a list,\n * the runtime emits a structured segment that `mount()` can dispatch\n * on — running its native keyed reconciler for the list parts and\n * leaving the static surrounds to the general-purpose diff.\n *\n * Why have a structured form at all: the perf bottleneck for huge\n * keyed lists isn't the per-row JSX work (which `each()` already\n * memoizes). It's that flattening every render's whole tree to one\n * big HTML string forces a full `innerHTML` parse and a tree walk\n * over rows we know are unchanged. The segment shape lets mount()\n * skip both for the list parts.\n */\n\nimport type { Binding } from './bindings.js';\n\nexport type Segment = StaticSegment | ListSegment | MixedSegment;\n\nexport interface StaticSegment {\n  kind: 'static';\n  html: string;\n}\n\nexport interface ListItem {\n  /**\n   * The row's object identity. Used by the reconciler to match new items\n   * against live DOM nodes across renders. Unchanged ref → reuse the\n   * existing live node; replaced ref → build a fresh node.\n   */\n  ref: object;\n  /**\n   * KF-294: the row's fine-grained binding specs (signals in row attrs/text).\n   * Undefined for granular-path rows (which snapshot in this spike). The\n   * snapshot reconciler wires these to the fresh row node and disposes them\n   * when the row is removed.\n   */\n  bindings?: Binding[];\n  /**\n   * Optional cache-invalidation key that captures external state affecting\n   * this row's render (e.g. selection class). Different cacheKey on the\n   * same `ref` triggers a cache miss for that row. `undefined` when the\n   * user didn't pass a `key` callback to `each()`.\n   */\n  cacheKey: unknown;\n  html: string;\n}\n\nexport interface ListSegment {\n  kind: 'list';\n  id: string;\n  items: ListItem[];\n  /**\n   * Optional granular patches (KF-92). When present, the list reconciler\n   * applies these directly to the existing binding instead of doing a\n   * full classify+reconcile pass. Emitted by `each()` when bound to an\n   * `arraySignal`. Mutually exclusive with the `items` snapshot in the\n   * sense that the snapshot is treated as informational/fall-back when\n   * patches are present.\n   */\n  patches?: ArrayPatchInternal[];\n  /**\n   * KF-388: the identity of the data this list renders — the `arraySignal`\n   * instance, or `undefined` for a plain array.\n   *\n   * A list's `id` is its call-order index, so a render that changes how many\n   * `each()` calls precede this one hands this segment a DIFFERENT list's\n   * binding. Patches are only meaningful against the binding they were queued\n   * for, so the reconciler compares this against the binding's recorded source\n   * before trusting the patch queue. It is an identity check, not a value\n   * check — the instance is never read.\n   */\n  source?: object;\n}\n\n/**\n * Internal patch shape used inside list segments. Mirrors `ArrayPatch<T>`\n * from `array-signal.ts` but typed against `object` so the segment layer\n * doesn't need to be generic. `update` / `insert` patches carry the row's\n * pre-rendered HTML — `each()` renders them at JSX-evaluation time inside a\n * try/catch so a throwing render falls back to the snapshot path (KF-99)\n * instead of leaving the signal and DOM divergent.\n */\nexport type ArrayPatchInternal =\n  | {\n      type: 'update';\n      index: number;\n      item: object;\n      html: string;\n      bindings?: Binding[];\n    }\n  | {\n      type: 'insert';\n      index: number;\n      item: object;\n      html: string;\n      bindings?: Binding[];\n    }\n  | { type: 'remove'; index: number }\n  | { type: 'move'; from: number; to: number }\n  | { type: 'replace'; items: readonly object[] };\n\n/**\n * Narrowed patch aliases. Array indexing loses the union discriminant, so\n * the granular reconciler casts through these instead of restating the full\n * object type at every site — a field rename is then a one-place edit.\n */\nexport type UpdatePatch = Extract<ArrayPatchInternal, { type: 'update' }>;\nexport type InsertPatch = Extract<ArrayPatchInternal, { type: 'insert' }>;\n\nexport interface MixedSegment {\n  kind: 'mixed';\n  parts: Segment[];\n}\n\n/**\n * Flatten a segment to a complete HTML string. Used for first render\n * (bulk innerHTML), for SSR-style consumption via `toString()`, and\n * for diagnostics.\n *\n * If `withMarkers` is set, list segments are wrapped in\n * `<!--kf-list:{id}-->` comments so the post-parse walk can find each\n * list's live parent. Plain (non-marker) flatten is what JSX consumers\n * see when they call `.toString()` on the SafeHtml.\n */\n/**\n * Comment-marker prefix emitted before each list (`<!--kf-list:{id}-->`).\n * `mount()` consumes it when binding lists from the live DOM — the emitter\n * (here) and the consumer must agree byte-for-byte, so both import this one\n * constant. Part of the reserved marker namespace (see `bindings.ts`).\n */\nexport const LIST_MARKER_PREFIX = 'kf-list:';\n\nexport function flatten(segment: Segment, withMarkers: boolean): string {\n  if (segment.kind === 'static') return segment.html;\n  if (segment.kind === 'list') {\n    const items = segment.items.map((i) => i.html).join('');\n    return withMarkers\n      ? `<!--${LIST_MARKER_PREFIX}${segment.id}-->${items}`\n      : items;\n  }\n  return segment.parts.map((p) => flatten(p, withMarkers)).join('');\n}\n\n/**\n * Variant of `flatten` for the static-only diff path on subsequent\n * renders. Lists are reduced to a single marker comment with no items\n * inside — the actual list children stay in the live DOM and are\n * reconciled separately. Keeping list items out of this string is\n * what makes the morph cheap on huge lists where most rows are\n * unchanged.\n */\nexport function flattenWithoutListItems(segment: Segment): string {\n  if (segment.kind === 'static') return segment.html;\n  if (segment.kind === 'list')\n    return `<!--${LIST_MARKER_PREFIX}${segment.id}-->`;\n  return segment.parts.map(flattenWithoutListItems).join('');\n}\n\n/** Collect every `ListSegment` in the tree, keyed by its id. */\nexport function collectLists(\n  segment: Segment,\n  out: Map<string, ListSegment> = new Map(),\n): Map<string, ListSegment> {\n  if (segment.kind === 'list') out.set(segment.id, segment);\n  else if (segment.kind === 'mixed') {\n    for (const part of segment.parts) collectLists(part, out);\n  }\n  return out;\n}\n\n/**\n * Combine a list of child segments into the smallest equivalent\n * representation: collapses adjacent statics into one static, returns\n * a single static if everything is static, otherwise a mixed segment\n * with statics coalesced.\n */\nexport function mergeChildSegments(parts: Segment[]): Segment {\n  if (parts.length === 0) return { kind: 'static', html: '' };\n  if (parts.every((p) => p.kind === 'static')) {\n    return {\n      kind: 'static',\n      html: parts.map((p) => (p as StaticSegment).html).join(''),\n    };\n  }\n  const merged: Segment[] = [];\n  let coalesced = '';\n  for (const p of parts) {\n    if (p.kind === 'static') {\n      coalesced += p.html;\n    } else {\n      if (coalesced !== '') {\n        merged.push({ kind: 'static', html: coalesced });\n        coalesced = '';\n      }\n      merged.push(p);\n    }\n  }\n  if (coalesced !== '') merged.push({ kind: 'static', html: coalesced });\n  return { kind: 'mixed', parts: merged };\n}\n\n/**\n * Wrap a child segment with surrounding open/close tags from the\n * parent JSX element. Used by the JSX runtime when constructing\n * `_jsx(tag, ...)` output.\n */\nexport function wrapWithTags(\n  child: Segment,\n  openTag: string,\n  closeTag: string,\n): Segment {\n  if (child.kind === 'static') {\n    return { kind: 'static', html: openTag + child.html + closeTag };\n  }\n  if (child.kind === 'mixed') {\n    return {\n      kind: 'mixed',\n      parts: [\n        { kind: 'static', html: openTag },\n        ...child.parts,\n        { kind: 'static', html: closeTag },\n      ],\n    };\n  }\n  return {\n    kind: 'mixed',\n    parts: [\n      { kind: 'static', html: openTag },\n      child,\n      { kind: 'static', html: closeTag },\n    ],\n  };\n}\n"]}

package/dist/{chunk-HW7KSM2Y.js → chunk-CEQMZYLR.js}

@@ -11,4 +11,4 @@ function clearDevHooks() {
 
 export { clearDevHooks, devHooks, installDevHooks };
 
-//# sourceMappingURL=chunk-HW7KSM2Y.js.map
+//# sourceMappingURL=chunk-CEQMZYLR.js.map

package/dist/{chunk-HW7KSM2Y.js.map → chunk-CEQMZYLR.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/dev-hooks.ts"],"names":[],"mappings":";AA8IO,IAAM,WAAqB;AAS3B,SAAS,gBAAgB,KAAA,EAAuB;AACrD,EAAA,MAAA,CAAO,MAAA,CAAO,UAAU,KAAK,CAAA;AAC/B;AAOO,SAAS,aAAA,GAAsB;AACpC,EAAA,KAAA,MAAW,GAAA,IAAO,MAAA,CAAO,IAAA,CAAK,QAAQ,CAAA,EAAG;AACvC,IAAA,OAAQ,SAAqC,GAAG,CAAA;AAAA,EAClD;AACF","file":"chunk-HW7KSM2Y.js","sourcesContent":["/**\n * The dev-hook registry — kerf's single seam between production code and the\n * opt-in development diagnostics.\n *\n * ## Why this exists\n *\n * kerf used to INFER whether it was running in development, by reading\n * `globalThis.process?.env?.NODE_ENV` through `utils/devMode.ts`. That\n * inference cannot be made correct, and it was wrong in the most common case:\n * bundlers substitute the BARE `process.env.NODE_ENV` token and never create a\n * `globalThis.process` object for browser targets, so the read returned\n * `undefined` and `undefined !== 'production'` resolved to DEVELOPMENT inside\n * production browser bundles.\n *\n * It also could not be fixed by rewriting the expression. Only the\n * *production* answer can be made static: `X && false` folds to a constant for\n * any side-effect-free `X`, while `X && true` does not. So any form that a\n * bundler can eliminate is also a form that treats \"no `process` binding\" as\n * production — which silently disables every warning in the no-build/CDN path\n * and in browser dev bundles.\n *\n * The fix is to stop guessing. Every environment already has a correct,\n * statically-foldable dev flag; what none of them offers is a way to hand that\n * flag to a *library*. So the consumer writes the conditional, in their own\n * code, with their own flag:\n *\n * ```js\n * if (import.meta.env.DEV) await import('kerfjs/dev');   // Vite\n * if (process.env.NODE_ENV !== 'production') await import('kerfjs/dev');\n * ```\n *\n * Because that condition folds to `false` in the consumer's production build,\n * the entire statement is eliminated and the dev chunk is never emitted or\n * fetched. Installation IS the development signal — there is nothing left to\n * detect, and no environment kerf can be wrong about.\n *\n * ## The contract\n *\n * Core modules never import a `dev-*` module. They read a nullable slot off\n * `devHooks` and call through it:\n *\n * ```ts\n * devHooks.listRebind?.(id, marker.parentElement as Element);\n * ```\n *\n * When nothing is installed every slot is `undefined`, so the cost is one\n * property read per call site and the `dev-*` modules are unreachable from the\n * main entry — which is what lets a bundler drop them. This is why the gate\n * lives at the CALL SITE rather than inside each warner: an unconditional call\n * into a self-gating warner keeps the module reachable no matter how the gate\n * is written, so no amount of dead-code elimination can reclaim it.\n *\n * Slots ending in `Enabled` are predicates rather than warnings. They exist for\n * the handful of call sites that must decide whether to do *expensive\n * preparatory work* — capturing the previous render's binding list, allocating\n * a per-render `Map` — before there is anything to warn about. Core must check\n * those before paying the cost, exactly as it checked the old `isOptedIn()`\n * exports.\n *\n * Each opt-in warner keeps its own internal switch check through `devFlag()`;\n * an `enableWarnings()` override wins over the matching `KERF_DEV_WARN_*`\n * environment variable. Installation decides whether the diagnostics are\n * *present*; the opt-in warner decides whether it is *switched on*. Always-on\n * hooks skip that second gate.\n *\n * @see docs/11-dev-warnings.md\n */\n\nimport type { Binding } from './bindings.js';\nimport type { ListBinding } from './list-binding.js';\nimport type { Signal } from './reactive.js';\n\n/** Per-mount / per-store one-shot dedup flag, owned by the caller in core. */\nexport interface WarnOnceContext {\n  warned: boolean;\n}\n\nexport interface DevHooks {\n  // --- reactive.ts -------------------------------------------------------\n  /**\n   * Replaces `signal()`'s constructor so writes to never-subscribed signals can\n   * warn. Resolved at signal-CREATION time, so signals created before the dev\n   * entry is installed stay plain — see `signalsCreatedBeforeInstall`.\n   */\n  signalFactory?: <T>(value: T) => Signal<T>;\n  /**\n   * Wraps an `effect()` body so `delegate()` can detect that it is running\n   * inside one. Returns the body to actually run.\n   */\n  wrapEffect?: (fn: () => void | (() => void)) => () => void | (() => void);\n\n  // --- delegate.ts -------------------------------------------------------\n  delegateInEffect?: (fn: 'delegate' | 'delegateCapture') => void;\n\n  // --- store.ts ----------------------------------------------------------\n  narrowSet?: (prev: unknown, next: unknown, ctx: WarnOnceContext) => void;\n  /** Deep read-only proxy for the `get()` snapshot, so stray writes throw. */\n  storeReadonly?: <T extends object>(state: T) => T;\n  /** Unwraps a proxy handed back through `set({ ...get() })`. */\n  storeToRaw?: <T>(next: T) => T;\n\n  // --- mount.ts ----------------------------------------------------------\n  listenerRebuild?: (rootEl: Element) => MutationObserver | null;\n  listIdShift?: (id: string) => void;\n  parserRepair?: (html: string) => void;\n  staleBindingEnabled?: () => boolean;\n  staleBinding?: (prevWired: readonly Binding[], current: readonly Binding[]) => void;\n  listInvariantsEnabled?: () => boolean;\n  listInvariants?: (\n    rootEl: Element,\n    bindings: ReadonlyMap<string, ListBinding>,\n    expectedCounts?: ReadonlyMap<string, number>,\n  ) => void;\n  valueOnlyRerender?: (prevHtml: string, nextHtml: string, ctx: WarnOnceContext) => void;\n  listRebind?: (id: string, liveParent: Element) => void;\n  eachInMorphSkip?: (id: string, liveParent: Element, rootEl: Element) => void;\n  missingRowKey?: (\n    rowEl: Element,\n    rowHtml: string,\n    binding: { warnedMissingKey?: boolean },\n  ) => void;\n\n  // --- each.ts -----------------------------------------------------------\n  staleIndexEnabled?: () => boolean;\n  staleIndex?: (id: string) => void;\n  duplicateCacheKeys?: (id: string, segItems: readonly { cacheKey: unknown }[]) => void;\n\n  // --- utils/url-screen.ts -----------------------------------------------\n  /**\n   * When installed, a screened URL throws instead of warning-and-dropping.\n   * A slot rather than a boolean so the check stays uniform with the rest.\n   */\n  urlScreenThrow?: (message: string) => never;\n}\n\n/**\n * The live slot table. Mutable by design — this is the fourth sanctioned\n * module-level mutable location (Design rule 5), and like `store.ts:REGISTRY`\n * it depends on there being exactly ONE copy at runtime. `tsup`'s\n * `splitting: true` guarantees that: shared modules are promoted into a single\n * chunk that both the main entry and the `kerfjs/dev` entry import.\n */\nexport const devHooks: DevHooks = {};\n\n/**\n * Install (or extend) the dev hooks. Called by the `kerfjs/dev` entry; not part\n * of the public API surface.\n *\n * Merges rather than replaces, so a consumer can install the standard bundle\n * and then override a single slot in a test.\n */\nexport function installDevHooks(hooks: DevHooks): void {\n  Object.assign(devHooks, hooks);\n}\n\n/**\n * Remove every installed hook. Exists for test isolation — a suite that asserts\n * the not-installed (production-shaped) path needs to get back to a clean slate\n * without reloading modules.\n */\nexport function clearDevHooks(): void {\n  for (const key of Object.keys(devHooks)) {\n    delete (devHooks as Record<string, unknown>)[key];\n  }\n}\n"]}
+{"version":3,"sources":["../src/dev-hooks.ts"],"names":[],"mappings":";AAwJO,IAAM,WAAqB;AAS3B,SAAS,gBAAgB,KAAA,EAAuB;AACrD,EAAA,MAAA,CAAO,MAAA,CAAO,UAAU,KAAK,CAAA;AAC/B;AAOO,SAAS,aAAA,GAAsB;AACpC,EAAA,KAAA,MAAW,GAAA,IAAO,MAAA,CAAO,IAAA,CAAK,QAAQ,CAAA,EAAG;AACvC,IAAA,OAAQ,SAAqC,GAAG,CAAA;AAAA,EAClD;AACF","file":"chunk-CEQMZYLR.js","sourcesContent":["/**\n * The dev-hook registry — kerf's single seam between production code and the\n * opt-in development diagnostics.\n *\n * ## Why this exists\n *\n * kerf used to INFER whether it was running in development, by reading\n * `globalThis.process?.env?.NODE_ENV` through `utils/devMode.ts`. That\n * inference cannot be made correct, and it was wrong in the most common case:\n * bundlers substitute the BARE `process.env.NODE_ENV` token and never create a\n * `globalThis.process` object for browser targets, so the read returned\n * `undefined` and `undefined !== 'production'` resolved to DEVELOPMENT inside\n * production browser bundles.\n *\n * It also could not be fixed by rewriting the expression. Only the\n * *production* answer can be made static: `X && false` folds to a constant for\n * any side-effect-free `X`, while `X && true` does not. So any form that a\n * bundler can eliminate is also a form that treats \"no `process` binding\" as\n * production — which silently disables every warning in the no-build/CDN path\n * and in browser dev bundles.\n *\n * The fix is to stop guessing. Every environment already has a correct,\n * statically-foldable dev flag; what none of them offers is a way to hand that\n * flag to a *library*. So the consumer writes the conditional, in their own\n * code, with their own flag:\n *\n * ```js\n * if (import.meta.env.DEV) await import('kerfjs/dev');   // Vite\n * if (process.env.NODE_ENV !== 'production') await import('kerfjs/dev');\n * ```\n *\n * Because that condition folds to `false` in the consumer's production build,\n * the entire statement is eliminated and the dev chunk is never emitted or\n * fetched. Installation IS the development signal — there is nothing left to\n * detect, and no environment kerf can be wrong about.\n *\n * ## The contract\n *\n * Core modules never import a `dev-*` module. They read a nullable slot off\n * `devHooks` and call through it:\n *\n * ```ts\n * devHooks.listRebind?.(id, marker.parentElement as Element);\n * ```\n *\n * When nothing is installed every slot is `undefined`, so the cost is one\n * property read per call site and the `dev-*` modules are unreachable from the\n * main entry — which is what lets a bundler drop them. This is why the gate\n * lives at the CALL SITE rather than inside each warner: an unconditional call\n * into a self-gating warner keeps the module reachable no matter how the gate\n * is written, so no amount of dead-code elimination can reclaim it.\n *\n * Slots ending in `Enabled` are predicates rather than warnings. They exist for\n * the handful of call sites that must decide whether to do *expensive\n * preparatory work* — capturing the previous render's binding list, allocating\n * a per-render `Map` — before there is anything to warn about. Core must check\n * those before paying the cost, exactly as it checked the old `isOptedIn()`\n * exports.\n *\n * Each opt-in warner keeps its own internal switch check through `devFlag()`;\n * an `enableWarnings()` override wins over the matching `KERF_DEV_WARN_*`\n * environment variable. Installation decides whether the diagnostics are\n * *present*; the opt-in warner decides whether it is *switched on*. Always-on\n * hooks skip that second gate.\n *\n * @see docs/11-dev-warnings.md\n */\n\nimport type { Binding } from './bindings.js';\nimport type { ListBinding } from './list-binding.js';\nimport type { Signal } from './reactive.js';\n\n/** Per-mount / per-store one-shot dedup flag, owned by the caller in core. */\nexport interface WarnOnceContext {\n  warned: boolean;\n}\n\nexport interface DevHooks {\n  // --- reactive.ts -------------------------------------------------------\n  /**\n   * Replaces `signal()`'s constructor so writes to never-subscribed signals can\n   * warn. Resolved at signal-CREATION time, so signals created before the dev\n   * entry is installed stay plain — see `signalsCreatedBeforeInstall`.\n   */\n  signalFactory?: <T>(value: T) => Signal<T>;\n  /**\n   * Wraps an `effect()` body so `delegate()` can detect that it is running\n   * inside one. Returns the body to actually run.\n   */\n  wrapEffect?: (fn: () => void | (() => void)) => () => void | (() => void);\n\n  // --- delegate.ts -------------------------------------------------------\n  delegateInEffect?: (fn: 'delegate' | 'delegateCapture') => void;\n\n  // --- store.ts ----------------------------------------------------------\n  narrowSet?: (prev: unknown, next: unknown, ctx: WarnOnceContext) => void;\n  /** Deep read-only proxy for the `get()` snapshot, so stray writes throw. */\n  storeReadonly?: <T extends object>(state: T) => T;\n  /** Unwraps a proxy handed back through `set({ ...get() })`. */\n  storeToRaw?: <T>(next: T) => T;\n\n  // --- mount.ts ----------------------------------------------------------\n  listenerRebuild?: (rootEl: Element) => MutationObserver | null;\n  listIdShift?: (id: string) => void;\n  parserRepair?: (html: string) => void;\n  staleBindingEnabled?: () => boolean;\n  staleBinding?: (\n    prevWired: readonly Binding[],\n    current: readonly Binding[],\n  ) => void;\n  listInvariantsEnabled?: () => boolean;\n  listInvariants?: (\n    rootEl: Element,\n    bindings: ReadonlyMap<string, ListBinding>,\n    expectedCounts?: ReadonlyMap<string, number>,\n  ) => void;\n  valueOnlyRerender?: (\n    prevHtml: string,\n    nextHtml: string,\n    ctx: WarnOnceContext,\n  ) => void;\n  listRebind?: (id: string, liveParent: Element) => void;\n  eachInMorphSkip?: (id: string, liveParent: Element, rootEl: Element) => void;\n  missingRowKey?: (\n    rowEl: Element,\n    rowHtml: string,\n    binding: { warnedMissingKey?: boolean },\n  ) => void;\n\n  // --- each.ts -----------------------------------------------------------\n  staleIndexEnabled?: () => boolean;\n  staleIndex?: (id: string) => void;\n  duplicateCacheKeys?: (\n    id: string,\n    segItems: readonly { cacheKey: unknown }[],\n  ) => void;\n\n  // --- utils/url-screen.ts -----------------------------------------------\n  /**\n   * When installed, a screened URL throws instead of warning-and-dropping.\n   * A slot rather than a boolean so the check stays uniform with the rest.\n   */\n  urlScreenThrow?: (message: string) => never;\n}\n\n/**\n * The live slot table. Mutable by design — this is the fourth sanctioned\n * module-level mutable location (Design rule 5), and like `store.ts:REGISTRY`\n * it depends on there being exactly ONE copy at runtime. `tsup`'s\n * `splitting: true` guarantees that: shared modules are promoted into a single\n * chunk that both the main entry and the `kerfjs/dev` entry import.\n */\nexport const devHooks: DevHooks = {};\n\n/**\n * Install (or extend) the dev hooks. Called by the `kerfjs/dev` entry; not part\n * of the public API surface.\n *\n * Merges rather than replaces, so a consumer can install the standard bundle\n * and then override a single slot in a test.\n */\nexport function installDevHooks(hooks: DevHooks): void {\n  Object.assign(devHooks, hooks);\n}\n\n/**\n * Remove every installed hook. Exists for test isolation — a suite that asserts\n * the not-installed (production-shaped) path needs to get back to a clean slate\n * without reloading modules.\n */\nexport function clearDevHooks(): void {\n  for (const key of Object.keys(devHooks)) {\n    delete (devHooks as Record<string, unknown>)[key];\n  }\n}\n"]}

package/dist/{chunk-SVATPF5R.js → chunk-DLY444MN.js}

@@ -1,9 +1,9 @@
-import { itemVersion } from './chunk-QIP723L4.js';
-import { parseRowTemplate, rowContractError, parseSingleRow, collectTemplateChildren } from './chunk-V46JKE44.js';
-import { captureRowBindings, listSafeHtml, boundTextNodeOf, syncFormProp, newBindingContext, disposeRowBindings, wireBindings, isSafeHtml, _setBindingContext, TEXT_MARKER_PREFIX, ROW_TEXT_PREFIX, wireRowBindings, carryOrRewireRowBindings, granularListSafeHtml } from './chunk-ZDCJZCNO.js';
-import { effect } from './chunk-U6FK33SG.js';
-import { LIST_MARKER_PREFIX, flattenWithoutListItems, collectLists, flatten } from './chunk-GY4XV2UV.js';
-import { devHooks } from './chunk-HW7KSM2Y.js';
+import { itemVersion } from './chunk-5WRGJZV6.js';
+import { parseRowTemplate, rowContractError, parseSingleRow, collectTemplateChildren } from './chunk-WKIPLNVO.js';
+import { captureRowBindings, listSafeHtml, boundTextNodeOf, syncFormProp, newBindingContext, disposeRowBindings, wireBindings, isSafeHtml, _setBindingContext, TEXT_MARKER_PREFIX, ROW_TEXT_PREFIX, wireRowBindings, carryOrRewireRowBindings, granularListSafeHtml } from './chunk-JRKE6XEK.js';
+import { effect } from './chunk-Y2FOYPBV.js';
+import { LIST_MARKER_PREFIX, flattenWithoutListItems, collectLists, flatten } from './chunk-BDX3R4OM.js';
+import { devHooks } from './chunk-CEQMZYLR.js';
 
 // src/list-render-state.ts
 function deriveListRenderState(bindingCount) {
@@ -18,7 +18,8 @@ function decideListPath(state, patches, snapshotLength, previousBindingCount) {
   for (const p of patches) {
     if (p.type === "insert") netDelta += 1;
     else if (p.type === "remove") netDelta -= 1;
-    else if (p.type === "replace") return { path: "snapshot", reason: "replace" };
+    else if (p.type === "replace")
+      return { path: "snapshot", reason: "replace" };
   }
   const count = previousBindingCount ?? 0;
   if (count + netDelta !== snapshotLength) {
@@ -153,10 +154,12 @@ function eachGranular(sig, render, cacheKey, listKey) {
       return eachSnapshotById(snapshot, render, cacheKey, id, sig);
     }
   }
-  const renderRow = (item, index) => captureRowBindings(() => inRowScope(() => {
-    const out = render(item, index);
-    return isSafeHtml(out) ? out.toString() : out;
-  }));
+  const renderRow = (item, index) => captureRowBindings(
+    () => inRowScope(() => {
+      const out = render(item, index);
+      return isSafeHtml(out) ? out.toString() : out;
+    })
+  );
   const internalPatches = new Array(patches.length);
   const cache = ctx.caches.get(id);
   try {
@@ -223,13 +226,16 @@ function eachSnapshotById(items, render, cacheKey, id, source) {
         devHooks.staleIndex?.(id);
       }
     } else {
-      const captured = captureRowBindings(() => inRowScope(() => {
-        const out = render(item, i);
-        return isSafeHtml(out) ? out.toString() : out;
-      }));
+      const captured = captureRowBindings(
+        () => inRowScope(() => {
+          const out = render(item, i);
+          return isSafeHtml(out) ? out.toString() : out;
+        })
+      );
       html = captured.html;
       bindings = captured.bindings;
-      if (cache !== null) cache.set(item, { cacheKey: k, html, bindings, version, index: i });
+      if (cache !== null)
+        cache.set(item, { cacheKey: k, html, bindings, version, index: i });
     }
     segItems[i] = { ref: item, cacheKey: k, html, bindings };
   }
@@ -281,12 +287,7 @@ function restoreFocus(snap) {
   if (domSelection === null) return;
   const [anchorNode, anchorOffset, focusNode, focusOffset] = domSelection;
   try {
-    document.getSelection()?.setBaseAndExtent(
-      anchorNode,
-      anchorOffset,
-      focusNode,
-      focusOffset
-    );
+    document.getSelection()?.setBaseAndExtent(anchorNode, anchorOffset, focusNode, focusOffset);
   } catch {
   }
 }
@@ -343,7 +344,11 @@ function protectionTag(node) {
   const { dataset } = node;
   return (dataset.morphSkip !== void 0 ? "s" : "") + (dataset.morphSkipChildren !== void 0 ? "c" : "") + (dataset.morphPreserve !== void 0 ? "p" : "");
 }
-var MARKER_PREFIXES = [LIST_MARKER_PREFIX, TEXT_MARKER_PREFIX, ROW_TEXT_PREFIX];
+var MARKER_PREFIXES = [
+  LIST_MARKER_PREFIX,
+  TEXT_MARKER_PREFIX,
+  ROW_TEXT_PREFIX
+];
 function isMarker(node) {
   if (node.nodeType !== COMMENT_NODE) return false;
   const { data } = node;
@@ -421,7 +426,8 @@ function morphChildren(fromParent, toParent, ownedItems) {
     if (matched === null && fromChild !== null && toChild.nodeType === COMMENT_NODE && toChild.data.startsWith(LIST_MARKER_PREFIX)) {
       const wantData = toChild.data;
       for (let scan = fromChild.nextSibling; scan !== null; scan = scan.nextSibling) {
-        if (scan.nodeType !== COMMENT_NODE || scan.data !== wantData) continue;
+        if (scan.nodeType !== COMMENT_NODE || scan.data !== wantData)
+          continue;
         const regionEnd = afterListRegion(scan, ownedItems);
         const run = [];
         for (let r = scan; r !== null && r !== regionEnd; r = r.nextSibling) {
@@ -534,7 +540,10 @@ function preserveTextEntryState(fromEl, toEl) {
     const toInput = toEl;
     toInput.value = fromInput.value;
     try {
-      toInput.setSelectionRange(fromInput.selectionStart, fromInput.selectionEnd);
+      toInput.setSelectionRange(
+        fromInput.selectionStart,
+        fromInput.selectionEnd
+      );
     } catch {
     }
   }
@@ -567,7 +576,8 @@ function tryAttributeOnlyFastPath(liveNode, oldHtml, newHtml) {
   if (oldGt === -1 || newGt === -1) return false;
   if (oldHtml.length - oldGt !== newHtml.length - newGt) return false;
   if (oldHtml.slice(oldGt) !== newHtml.slice(newGt)) return false;
-  if (containsDataMorphSkip(oldHtml) || containsDataMorphSkip(newHtml)) return false;
+  if (containsDataMorphSkip(oldHtml) || containsDataMorphSkip(newHtml))
+    return false;
   const oldTag = parseOpeningTag(oldHtml, oldGt);
   const newTag = parseOpeningTag(newHtml, newGt);
   if (oldTag === null || newTag === null) return false;
@@ -595,7 +605,8 @@ function tryAttributeOnlyFastPath(liveNode, oldHtml, newHtml) {
   return true;
 }
 function tryTextContentFastPath(liveNode, oldHtml, newHtml) {
-  if (containsDataMorphSkip(oldHtml) || containsDataMorphSkip(newHtml)) return false;
+  if (containsDataMorphSkip(oldHtml) || containsDataMorphSkip(newHtml))
+    return false;
   let p = 0;
   const minLen = Math.min(oldHtml.length, newHtml.length);
   while (p < minLen && oldHtml.charCodeAt(p) === newHtml.charCodeAt(p)) p++;
@@ -610,7 +621,8 @@ function tryTextContentFastPath(liveNode, oldHtml, newHtml) {
   if (!isPureTextWindow(newHtml, p, newWinEnd)) return false;
   if (p === 0) return false;
   const boundaryCc = oldHtml.charCodeAt(p - 1);
-  if (boundaryCc === LT || boundaryCc === DQUOTE || boundaryCc === SQUOTE || boundaryCc === EQ || boundaryCc === AMP) return false;
+  if (boundaryCc === LT || boundaryCc === DQUOTE || boundaryCc === SQUOTE || boundaryCc === EQ || boundaryCc === AMP)
+    return false;
   const textStart = lastIndexOfChar(oldHtml, GT, p - 1);
   if (textStart === -1) return false;
   const textEnd = oldHtml.indexOf("<", p);
@@ -637,7 +649,8 @@ function containsDataMorphSkip(html) {
 function isPureTextWindow(html, start, end) {
   for (let i = start; i < end; i++) {
     const cc = html.charCodeAt(i);
-    if (cc === LT || cc === GT || cc === DQUOTE || cc === SQUOTE || cc === AMP || cc === EQ) return false;
+    if (cc === LT || cc === GT || cc === DQUOTE || cc === SQUOTE || cc === AMP || cc === EQ)
+      return false;
   }
   return true;
 }
@@ -769,7 +782,14 @@ function reconcileGranular(binding, patches) {
       if (runLen === 1) {
         applySingleInsert(liveParent, items, patch, endAnchor(binding));
       } else {
-        applyBulkInsert(liveParent, items, patches, i, runEnd, endAnchor(binding));
+        applyBulkInsert(
+          liveParent,
+          items,
+          patches,
+          i,
+          runEnd,
+          endAnchor(binding)
+        );
       }
       i = runEnd;
       continue;
@@ -881,7 +901,10 @@ function applyBulkUpdate(liveParent, items, patches, start, end) {
     morphChanges.push({ patchIdx: k, html: p.html });
   }
   if (morphChanges.length === 0) return;
-  const { content, count } = parseRowTemplate(morphChanges.map((c) => c.html).join(""), liveParent);
+  const { content, count } = parseRowTemplate(
+    morphChanges.map((c) => c.html).join(""),
+    liveParent
+  );
   if (count !== morphChanges.length) {
     throw findOffendingChange(patches, morphChanges, liveParent);
   }
@@ -924,18 +947,30 @@ function applyBulkInsert(liveParent, items, patches, start, end, tailAnchor) {
 function findOffendingInsert(patches, start, htmls, liveParent) {
   for (let i = 0; i < htmls.length; i++) {
     if (parseRowTemplate(htmls[i], liveParent).count !== 1) {
-      return rowContractError(patches[start + i].index, htmls[i], liveParent);
+      return rowContractError(
+        patches[start + i].index,
+        htmls[i],
+        liveParent
+      );
     }
   }
-  return new Error("each(): bulk-insert mismatch with no per-row offender (kerf bug).");
+  return new Error(
+    "each(): bulk-insert mismatch with no per-row offender (kerf bug)."
+  );
 }
 function findOffendingChange(patches, changes, liveParent) {
   for (const c of changes) {
     if (parseRowTemplate(c.html, liveParent).count !== 1) {
-      return rowContractError(patches[c.patchIdx].index, c.html, liveParent);
+      return rowContractError(
+        patches[c.patchIdx].index,
+        c.html,
+        liveParent
+      );
     }
   }
-  return new Error("each(): bulk-update mismatch with no per-row offender (kerf bug).");
+  return new Error(
+    "each(): bulk-update mismatch with no per-row offender (kerf bug)."
+  );
 }
 
 // src/list-reconcile-inplace.ts
@@ -960,7 +995,12 @@ function tryInPlaceContentUpdate(binding, listSeg) {
 }
 function updateRowInPlace(liveParent, old, ni, index) {
   if (old.html === ni.html || tryAttributeOnlyFastPath(old.node, old.html, ni.html) || tryTextContentFastPath(old.node, old.html, ni.html)) {
-    const kept = carryOrRewireRowBindings(old.node, old.bindings, old.bindingDisposers, ni.bindings);
+    const kept = carryOrRewireRowBindings(
+      old.node,
+      old.bindings,
+      old.bindingDisposers,
+      ni.bindings
+    );
     return {
       ref: ni.ref,
       cacheKey: ni.cacheKey,
@@ -973,7 +1013,12 @@ function updateRowInPlace(liveParent, old, ni, index) {
   const newNode = parseSingleRow(ni.html, index, liveParent);
   if (old.node.tagName === newNode.tagName) {
     _morphElement(old.node, newNode);
-    const kept = carryOrRewireRowBindings(old.node, old.bindings, old.bindingDisposers, ni.bindings);
+    const kept = carryOrRewireRowBindings(
+      old.node,
+      old.bindings,
+      old.bindingDisposers,
+      ni.bindings
+    );
     return {
       ref: ni.ref,
       cacheKey: ni.cacheKey,
@@ -985,7 +1030,12 @@ function updateRowInPlace(liveParent, old, ni, index) {
   }
   disposeRowBindings(old.bindingDisposers);
   liveParent.replaceChild(newNode, old.node);
-  const fresh = carryOrRewireRowBindings(newNode, void 0, void 0, ni.bindings);
+  const fresh = carryOrRewireRowBindings(
+    newNode,
+    void 0,
+    void 0,
+    ni.bindings
+  );
   return {
     ref: ni.ref,
     cacheKey: ni.cacheKey,
@@ -1070,15 +1120,22 @@ function buildFreshNodes(newRecord, freshIndices, freshHtmls, liveParent) {
 function findOffendingRow(newRecord, freshIndices, freshHtmls, liveParent) {
   for (let i = 0; i < freshHtmls.length; i++) {
     if (parseRowTemplate(freshHtmls[i], liveParent).count !== 1) {
-      return rowContractError(freshIndices[i], newRecord[freshIndices[i]].html, liveParent);
+      return rowContractError(
+        freshIndices[i],
+        newRecord[freshIndices[i]].html,
+        liveParent
+      );
     }
   }
-  return new Error("each(): bulk-parse mismatch with no per-row offender (kerf bug).");
+  return new Error(
+    "each(): bulk-parse mismatch with no per-row offender (kerf bug)."
+  );
 }
 function removeOldNodes(liveParent, removedItems) {
   for (const item of removedItems) {
     disposeRowBindings(item.bindingDisposers);
-    if (item.node.parentElement === liveParent) liveParent.removeChild(item.node);
+    if (item.node.parentElement === liveParent)
+      liveParent.removeChild(item.node);
   }
 }
 function applyMoves(liveParent, newRecord, prevIdx, stable, tailAnchor) {
@@ -1160,7 +1217,8 @@ function assertNotInsideMountedTree(rootEl) {
     ancestor = ancestor.parentElement;
   }
   const stack = [];
-  for (let i = 0; i < rootEl.children.length; i++) stack.push(rootEl.children[i]);
+  for (let i = 0; i < rootEl.children.length; i++)
+    stack.push(rootEl.children[i]);
   while (stack.length > 0) {
     const cur = stack.pop();
     if (isMounted(cur)) throw new Error(NESTED_MOUNT_MSG);
@@ -1241,7 +1299,8 @@ function mount(rootEl, render) {
         valueOnlyWarnCtx
       );
       if (anyRebuiltListIsGranular(segment, renderCtx.rebuiltLists)) {
-        for (const id of renderCtx.rebuiltLists) renderCtx.bindingCounts.delete(id);
+        for (const id of renderCtx.rebuiltLists)
+          renderCtx.bindingCounts.delete(id);
         result = runRenderPass();
         segment = resultToSegment(result);
         nextStaticHtml = runSubsequentRender(
@@ -1255,7 +1314,8 @@ function mount(rootEl, render) {
       }
       if (nextStaticHtml !== prevStaticHtml) {
         bindingDisposers = wireBindings(rootEl, bindingCtx, bindingDisposers);
-        if (devHooks.staleBindingEnabled?.()) prevWiredBindings = bindingCtx.list;
+        if (devHooks.staleBindingEnabled?.())
+          prevWiredBindings = bindingCtx.list;
       } else {
         devHooks.staleBinding?.(prevWiredBindings, bindingCtx.list);
       }
@@ -1307,12 +1367,22 @@ function runSubsequentRender(rootEl, segment, bindings, renderCtx, prevStaticHtm
   if (currentStaticHtml === prevStaticHtml) {
     return prevStaticHtml;
   }
-  devHooks.valueOnlyRerender?.(prevStaticHtml, currentStaticHtml, valueOnlyWarnCtx);
+  devHooks.valueOnlyRerender?.(
+    prevStaticHtml,
+    currentStaticHtml,
+    valueOnlyWarnCtx
+  );
   cleanupOrphanBindings(segment, bindings, renderCtx);
   const template = rootEl.cloneNode(false);
   template.innerHTML = currentStaticHtml;
   morph(rootEl, template, collectOwnedItems(bindings));
-  bindListsFromMarkers(rootEl, segment, bindings, false, renderCtx.rebuiltLists);
+  bindListsFromMarkers(
+    rootEl,
+    segment,
+    bindings,
+    false,
+    renderCtx.rebuiltLists
+  );
   return currentStaticHtml;
 }
 function coerceRenderResult(result) {
@@ -1339,7 +1409,8 @@ function bindListsFromMarkers(rootEl, segment, bindings, inlinedItems, rebuiltLi
     const id = marker.data.slice(LIST_MARKER_PREFIX.length);
     const existing = bindings.get(id);
     if (existing) {
-      if (existing.marker === marker && rootEl.contains(existing.marker)) continue;
+      if (existing.marker === marker && rootEl.contains(existing.marker))
+        continue;
       for (const item of existing.items) {
         disposeRowBindings(item.bindingDisposers);
         if (rootEl.contains(item.node)) {
@@ -1385,7 +1456,8 @@ function validateInlinedRowMatch(expectedHtml, index, boundEl, liveParent) {
   const { content, count } = parseRowTemplate(expectedHtml, liveParent);
   if (count !== 1) throw rowContractError(index, expectedHtml, liveParent);
   const expectedTag = content.firstElementChild.tagName;
-  if (boundEl.tagName !== expectedTag) throw rowStructureError(index, boundEl.tagName, expectedTag);
+  if (boundEl.tagName !== expectedTag)
+    throw rowStructureError(index, boundEl.tagName, expectedTag);
 }
 function rowStructureError(index, gotTag, wantTag) {
   const got = gotTag.toLowerCase();
@@ -1425,4 +1497,4 @@ function collectComments(node, out) {
 
 export { captureFocus, each, morph, mount, moveNode, restoreFocus };
 
-//# sourceMappingURL=chunk-SVATPF5R.js.map
+//# sourceMappingURL=chunk-DLY444MN.js.map