@firsthandjs/dom 0.9.1 → 0.10.1

package/dist/hydrate.dev.js

@@ -1,9 +1,9 @@
 import {
   mount
-} from "./dev-chunk-6V32MCOI.js";
+} from "./dev-chunk-KJHYMOKB.js";
 import {
   hydration
-} from "./dev-chunk-ADHDPKZW.js";
+} from "./dev-chunk-U46CIJCO.js";
 
 // packages/dom/src/hydrate.ts
 var COMMENT_NODE = 8;
@@ -65,43 +65,47 @@ function claimRegion(parent, marker) {
       return offered;
     }
   }
+  const bounds = boundsOf(parent, marker);
+  if (bounds === null) {
+    return null;
+  }
+  const { end } = bounds;
+  cursors.set(parent, end === null ? null : end.nextSibling);
+  return claimedOf(bounds.start === end ? null : bounds.start, end);
+}
+function claimedOf(start, end) {
+  const nodes = [];
+  for (let one = start; one !== null && one !== end; one = one.nextSibling) {
+    nodes.push(one);
+  }
+  const only = nodes.length === 1 ? nodes[0] : null;
+  return {
+    nodes: nodes.length === 0 ? null : only ?? nodes,
+    text: only !== null && only.nodeType === TEXT_NODE ? only.data : void 0,
+    region: { node: start, end }
+  };
+}
+function boundsOf(parent, marker) {
   const held = cursors.get(parent);
   const fromTheTop = held === void 0;
   const node = fromTheTop ? parent.firstChild : held;
-  let start;
-  let end;
   const stop = fromTheTop ? marker : null;
   let open = node;
   while (open !== null && open !== stop && !isOpen(open)) {
     open = open.nextSibling;
   }
   if (open !== null && open !== stop) {
-    end = closeOf(open);
+    const end = closeOf(open);
     if (marker !== null && marker !== end) {
       return null;
     }
     openers.push(open);
-    start = open.nextSibling;
-  } else if (fromTheTop) {
-    start = node;
-    end = marker;
-  } else {
-    return null;
-  }
-  cursors.set(parent, end === null ? null : end.nextSibling);
-  if (start === end) {
-    start = null;
+    return { start: open.nextSibling, end };
   }
-  const nodes = [];
-  for (let one = start; one !== null && one !== end; one = one.nextSibling) {
-    nodes.push(one);
+  if (fromTheTop) {
+    return { start: node, end: marker };
   }
-  const only = nodes.length === 1 ? nodes[0] : null;
-  return {
-    nodes: nodes.length === 0 ? null : only ?? nodes,
-    text: only !== null && only.nodeType === TEXT_NODE ? only.data : void 0,
-    region: { node: start, end }
-  };
+  return null;
 }
 function place(anchor) {
   const node = claim === null ? null : claim.node;

package/dist/hydrate.js

@@ -1 +1 @@
-import{b as T}from"./chunk-6BRSYQCI.js";import{b as a}from"./chunk-P4PXTIUD.js";var m=8,C=3,w="[",t=null,p=0,g=new WeakMap,c=[],N=new Map;function F(e,n=document.body){return T(e,n,o=>{M(n,o)})}function M(e,n){let o=t,l=p;p++,a.current=j,t={node:e.firstChild,end:null};try{return n()}finally{t=o,p=l,p===0&&(a.current=null,O())}}function O(){for(let e=0;e<c.length;e++){let n=c[e];n.parentNode?.removeChild(n)}c=[],g=new WeakMap,N=new Map}function S(e){if(t===null)return null;let n=t.node;if(n===null||n.nodeName!==e)return null;let o=n.nextSibling;return t.node=o===t.end?null:o,n}function v(e,n){if(n!==null){let r=N.get(n);if(r!==void 0)return N.delete(n),r}let o=g.get(e),l=o===void 0,h=l?e.firstChild:o,d,u,x=l?n:null,i=h;for(;i!==null&&i!==x&&!y(i);)i=i.nextSibling;if(i!==null&&i!==x){if(u=b(i),n!==null&&n!==u)return null;c.push(i),d=i.nextSibling}else if(l)d=h,u=n;else return null;g.set(e,u===null?null:u.nextSibling),d===u&&(d=null);let s=[];for(let r=d;r!==null&&r!==u;r=r.nextSibling)s.push(r);let f=s.length===1?s[0]:null;return{nodes:s.length===0?null:f??s,text:f!==null&&f.nodeType===C?f.data:void 0,region:{node:d,end:u}}}function E(e){let n=t===null?null:t.node,o=n?.parentNode??null;return o?.insertBefore(e,n),o}function D(e,n){let o=t;t=e;try{return n()}finally{t=o}}function y(e){return e!==null&&e.nodeType===m&&e.nodeValue===w}function b(e){let n=0;for(let o=e.nextSibling;o!==null;o=o.nextSibling)if(o.nodeType===m){if(y(o)){n++;continue}if(n===0)return o;n--}return null}function R(e){return y(e)?b(e):e}function W(e){return e.slice(1,e.search(/[\s/>]/)).toUpperCase()}function V(e,n,o,l){n.insertBefore(o,l.region.end),e.node=l.nodes===null?o:[...Array.isArray(l.nodes)?l.nodes:[l.nodes],o],N.set(o,l)}var j={tag:W,adopt:S,claim:v,within:D,keep:V,step:R,place:E};export{S as adopt,v as claimRegion,F as hydrate,M as hydrateWith,E as place,D as within};
+import{b as g}from"./chunk-YX6HJXS6.js";import{b as f}from"./chunk-467WEPXM.js";var y=8,x=3,T="[",l=null,r=0,c=new WeakMap,d=[],s=new Map;function A(n,o=document.body){return g(n,o,e=>{m(o,e)})}function m(n,o){let e=l,t=r;r++,f.current=W,l={node:n.firstChild,end:null};try{return o()}finally{l=e,r=t,r===0&&(f.current=null,b())}}function b(){for(let n=0;n<d.length;n++){let o=d[n];o.parentNode?.removeChild(o)}d=[],c=new WeakMap,s=new Map}function C(n){if(l===null)return null;let o=l.node;if(o===null||o.nodeName!==n)return null;let e=o.nextSibling;return l.node=e===l.end?null:e,o}function O(n,o){if(o!==null){let u=s.get(o);if(u!==void 0)return s.delete(o),u}let e=M(n,o);if(e===null)return null;let{end:t}=e;return c.set(n,t===null?null:t.nextSibling),w(e.start===t?null:e.start,t)}function w(n,o){let e=[];for(let u=n;u!==null&&u!==o;u=u.nextSibling)e.push(u);let t=e.length===1?e[0]:null;return{nodes:e.length===0?null:t??e,text:t!==null&&t.nodeType===x?t.data:void 0,region:{node:n,end:o}}}function M(n,o){let e=c.get(n),t=e===void 0,u=t?n.firstChild:e,N=t?o:null,i=u;for(;i!==null&&i!==N&&!p(i);)i=i.nextSibling;if(i!==null&&i!==N){let a=h(i);return o!==null&&o!==a?null:(d.push(i),{start:i.nextSibling,end:a})}return t?{start:u,end:o}:null}function S(n){let o=l===null?null:l.node,e=o?.parentNode??null;return e?.insertBefore(n,o),e}function v(n,o){let e=l;l=n;try{return o()}finally{l=e}}function p(n){return n!==null&&n.nodeType===y&&n.nodeValue===T}function h(n){let o=0;for(let e=n.nextSibling;e!==null;e=e.nextSibling)if(e.nodeType===y){if(p(e)){o++;continue}if(o===0)return e;o--}return null}function E(n){return p(n)?h(n):n}function D(n){return n.slice(1,n.search(/[\s/>]/)).toUpperCase()}function R(n,o,e,t){o.insertBefore(e,t.region.end),n.node=t.nodes===null?e:[...Array.isArray(t.nodes)?t.nodes:[t.nodes],e],s.set(e,t)}var W={tag:D,adopt:C,claim:O,within:v,keep:R,step:E,place:S};export{C as adopt,O as claimRegion,A as hydrate,m as hydrateWith,S as place,v as within};

package/dist/index.d.ts

@@ -4,7 +4,8 @@
  * Re-exports the reactive core so that applications have one import site.
  */
 export { component, defineElement, setElementPrefix, createComponent, view } from './component.js';
-export { setComponentAdapter, FirsthandComponentError } from './adapter.js';
+export { setComponentAdapter } from './adapter.js';
+export { FirsthandComponentError } from './errors.js';
 export type { ComponentAdapter } from './adapter.js';
 export type { Component, ComponentOptions, AttributeCodec, View, Render } from './component.js';
 export { render } from './render.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACnG,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5E,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EACL,MAAM,EACN,QAAQ,EACR,MAAM,EACN,KAAK,EACL,OAAO,EACP,SAAS,EACT,UAAU,EACV,UAAU,EACV,YAAY,EACZ,aAAa,EACb,OAAO,EACP,UAAU,EACV,qBAAqB,EACrB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,WAAW,EACX,OAAO,EACP,YAAY,EACZ,OAAO,EACP,YAAY,EACZ,aAAa,EACb,MAAM,GACP,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACnG,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtD,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EACL,MAAM,EACN,QAAQ,EACR,MAAM,EACN,KAAK,EACL,OAAO,EACP,SAAS,EACT,UAAU,EACV,UAAU,EACV,YAAY,EACZ,aAAa,EACb,OAAO,EACP,UAAU,EACV,qBAAqB,EACrB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,WAAW,EACX,OAAO,EACP,YAAY,EACZ,OAAO,EACP,YAAY,EACZ,aAAa,EACb,MAAM,GACP,MAAM,mBAAmB,CAAC"}

package/dist/index.dev.js

@@ -10,11 +10,11 @@ import {
   setComponentAdapter,
   setElementPrefix,
   view
-} from "./dev-chunk-MKONDKMD.js";
+} from "./dev-chunk-HLMVSIC4.js";
 import {
   render
-} from "./dev-chunk-6V32MCOI.js";
-import "./dev-chunk-ADHDPKZW.js";
+} from "./dev-chunk-KJHYMOKB.js";
+import "./dev-chunk-U46CIJCO.js";
 
 // packages/dom/src/portal.ts
 import { onCleanup } from "@firsthandjs/core";

package/dist/index.js

@@ -1 +1 @@
-import{a as d,b as i,e as f,f as s,h as a,i as m,j as l,k as x,l as C,m as h,x as y}from"./chunk-E4GAI5XA.js";import{a as c}from"./chunk-6BRSYQCI.js";import"./chunk-P4PXTIUD.js";import{onCleanup as u}from"@firsthandjs/core";function N(e,t){let o=[];p(e,o);for(let r=0;r<o.length;r++)t.appendChild(o[r]);return u(()=>{for(let r=0;r<o.length;r++){let n=o[r];n.parentNode?.removeChild(n)}}),null}function p(e,t){if(!(e==null||typeof e=="boolean")){if(Array.isArray(e)){for(let o=0;o<e.length;o++)p(e[o],t);return}if(typeof e=="object"&&typeof e.nodeType=="number"){t.push(e);return}t.push(document.createTextNode(String(e)))}}import{signal as D,computed as S,effect as T,batch as V,untrack as W,onCleanup as q,createRoot as z,catchError as B,runWithOwner as G,createContext as H,provide as I,useContext as J,FirsthandContextError as K,FirsthandCycleError as L,FirsthandReadonlyError as M}from"@firsthandjs/core";export{i as FirsthandComponentError,K as FirsthandContextError,L as FirsthandCycleError,M as FirsthandReadonlyError,V as batch,B as catchError,s as component,S as computed,m as createComponent,H as createContext,z as createRoot,l as defineElement,T as effect,x as list,y as mergeProps,h as off,C as on,q as onCleanup,N as portal,I as provide,c as render,G as runWithOwner,d as setComponentAdapter,f as setElementPrefix,D as signal,W as untrack,J as useContext,a as view};
+import{a as d,b as i,e as f,f as s,h as m,i as a,j as l,k as x,l as C,m as h,x as y}from"./chunk-MWEKNBIC.js";import{a as c}from"./chunk-YX6HJXS6.js";import"./chunk-467WEPXM.js";import{onCleanup as u}from"@firsthandjs/core";function N(e,t){let o=[];p(e,o);for(let r=0;r<o.length;r++)t.appendChild(o[r]);return u(()=>{for(let r=0;r<o.length;r++){let n=o[r];n.parentNode?.removeChild(n)}}),null}function p(e,t){if(!(e==null||typeof e=="boolean")){if(Array.isArray(e)){for(let o=0;o<e.length;o++)p(e[o],t);return}if(typeof e=="object"&&typeof e.nodeType=="number"){t.push(e);return}t.push(document.createTextNode(String(e)))}}import{signal as S,computed as T,effect as V,batch as W,untrack as q,onCleanup as z,createRoot as B,catchError as G,runWithOwner as H,createContext as I,provide as J,useContext as K,FirsthandContextError as L,FirsthandCycleError as M,FirsthandReadonlyError as Q}from"@firsthandjs/core";export{d as FirsthandComponentError,L as FirsthandContextError,M as FirsthandCycleError,Q as FirsthandReadonlyError,W as batch,G as catchError,s as component,T as computed,a as createComponent,I as createContext,B as createRoot,l as defineElement,V as effect,x as list,y as mergeProps,h as off,C as on,z as onCleanup,N as portal,J as provide,c as render,H as runWithOwner,i as setComponentAdapter,f as setElementPrefix,S as signal,q as untrack,K as useContext,m as view};

package/dist/insert.d.ts

@@ -1,7 +1,14 @@
-import { type Owner, type Signal } from '@firsthandjs/core';
+/**
+ * A dynamic child position: what fills it, and when it is filled again.
+ *
+ * `insert` binds one; `applyChild` writes whatever a part produced into one.
+ * The two are mutually recursive by nature — an array of children is children —
+ * which is why they are one module rather than two.
+ */
+import { type Owner } from '@firsthandjs/core';
 import { type Claimed } from './claim.js';
-/** What a child part currently owns in the DOM. */
-export type ChildSlot = Node | Node[] | null;
+import { type ChildSlot } from './nodes.js';
+export type { ChildSlot } from './nodes.js';
 /**
  * Runs `body` with the parts inside it excused from removing their nodes.
  *
@@ -55,88 +62,32 @@ export type DynamicChild = {
 export declare function part(thunk: () => unknown): DynamicChild;
 export declare function isDynamicChild(value: object): value is DynamicChild;
 /**
- * One place a run writes to, and what it last put there.
- *
- * A render function runs as a whole, so the DOM it describes has to be the DOM
- * it already made: created on the first run, written on every one after. These
- * records are what survives between runs — the node, and the last value, so a
- * run that produces what is already on screen writes nothing.
- */
-export type Slot = {
-    /** What this site made, or what a write currently owns. */
-    node?: ChildSlot;
-    /** The last primitive written here, when the last thing written was one. */
-    text?: string | undefined;
-    /** The last value written to an attribute or a property. */
-    last?: unknown;
-    /** What the site made besides its node: parts, listeners, components. */
-    owner?: Owner;
-    /** The run that last reached this site. */
-    seen?: number;
-    /** A prop a run feeds a child, held so the child keeps its instance. */
-    cell?: Signal<unknown>;
-};
-/**
- * Where a run keeps its sites.
+ * What only the runtime passes, and the compiler never does.
  *
- * One per instance, made in the setup — which runs once, so there is nothing
- * to look up and nothing ambient. What a site makes belongs to `owner`, the
- * component's own, rather than to the run that happened to make it: a run's
- * scope is cleared before it runs again, and anything left there would be
- * disposed by the second run.
+ * Two hand-offs that exist for one caller each, grouped rather than added to
+ * the signature: `insert` is the compiler/runtime protocol, and its arity is
+ * part of that protocol (ARCHITECTURE section 1.1). Both paths that pass this
+ * happen once per part rather than once per row, so the object costs nothing
+ * anybody can measure.
  */
-export type Store = {
-    slots: (Slot | undefined)[];
-    owner: Owner | null;
-    /** Which run is in progress, so that what it did not reach can be found. */
-    generation: number;
-    /** The component this belongs to, for what development has to say about it. */
-    name: string;
-    /** Whether this run has changed anything. Development only. */
-    busy?: boolean;
-    /** How many runs in a row have changed nothing. Development only. */
-    quiet?: number;
+export type InsertOptions = {
+    /**
+     * A region already claimed, handed down rather than looked up.
+     *
+     * How a part that turns out to produce another part gives the markup it
+     * claimed to the part that will actually own it — see the `function` branch
+     * in `run` below.
+     */
+    seed?: Claimed | null;
+    /**
+     * Told what this part currently has in the document, after every run.
+     *
+     * A keyed list needs it: a row that is a view owns nodes that change without
+     * the list running, and a reorder has to move what the row has now rather
+     * than what it had when it was made.
+     */
+    report?: Report;
 };
-/** Declared once per instance by the compiler, in the setup. */
-export declare function store(name?: string): Store;
-/** Notes that this run has actually changed something. */
-export declare function wrote(store: Store): void;
-/** The record for one site, made the first time a run reaches it. */
-export declare function site(store: Store, index: number): Slot;
-/**
- * Opens a site: what it makes now belongs to the instance, not to this run.
- *
- * Returns the owner to restore, which the compiler hands back to `close`.
- */
-export declare function open(store: Store, slot: Slot): Owner | null;
-export declare function close(previous: Owner | null): void;
-/**
- * Ends a run, and disposes what it did not reach.
- *
- * A branch the run has left is gone, not hidden: its components run their
- * cleanups and its parts stop, exactly as if the markup had never been there.
- * Coming back builds it again. That is what the control flow says, so it is
- * what happens.
- */
-export declare function ran<T>(store: Store, value: T): T;
-/**
- * A prop whose value belongs to the run, as something the child can hold.
- *
- * The child keeps its instance across runs, so its props cannot be getters
- * over the run that made them — that value belongs to one call. It gets a cell
- * instead, made the first time and written afterwards, so a prop that did not
- * change wakes nothing.
- */
-export declare function cell(store: Store, index: number, value: unknown): Signal<unknown>;
-/**
- * Writes a child position a run owns.
- *
- * The same text twice is not a write: `data` would accept it, and measuring
- * says that comparing a remembered string costs half what setting one does.
- * Anything else goes through `applyChild`, where a node that has not moved is
- * recognised and left where it is.
- */
-export declare function writeChild(store: Store, index: number, parent: Node, marker: Node | null, value: unknown): void;
 /**
  * Binds a dynamic child position.
  *
@@ -144,27 +95,17 @@ export declare function writeChild(store: Store, index: number, parent: Node, ma
  * The thunk is evaluated once inside a tracking scope; if it read nothing
  * reactive, no effect is retained (ADR-0009).
  */
-export declare function insert(parent: Node, value: unknown, marker?: Node | null, 
-/**
- * A region already claimed, handed down rather than looked up.
- *
- * The compiler never passes this. It is how a part that turns out to
- * produce another part gives the markup it claimed to the part that will
- * actually own it — see the `function` branch below.
- */
-seed?: Claimed | null, 
+export declare function insert(parent: Node, value: unknown, marker?: Node | null, options?: InsertOptions): void;
+/** Told what a part has in the document, when somebody needs to know. */
+export type Report = (nodes: Node[]) => void;
 /**
- * Told what this part currently has in the document, after every run.
+ * Applies one value to a child slot and returns the slot's new contents.
  *
- * The compiler never passes this either. A keyed list needs it: a row that
- * is a view owns nodes that change without the list running, and a reorder
- * has to move what the row has now rather than what it had when it was
- * made.
+ * The two branches that answer for almost every write are first and inline:
+ * nothing, and a primitive. Everything else is a shape that costs more than the
+ * call to reach it, so it lives in `applyOther` and this function stays small
+ * enough to read in one go.
  */
-report?: Report): void;
-/** Told what a part has in the document, when somebody needs to know. */
-export type Report = (nodes: Node[]) => void;
-/** Applies one value to a child slot and returns the slot's new contents. */
 export declare function applyChild(parent: Node, marker: Node | null, current: ChildSlot, value: unknown): ChildSlot;
 /**
  * Binds parts whose anchors are now in the document.
@@ -173,33 +114,6 @@ export declare function applyChild(parent: Node, marker: Node | null, current: C
  * disposal and error ownership lexical. A part created outside any scope —
  * runtime JSX at module level, say — is bound under the scope doing the
  * inserting, so that it is still disposed by something rather than by nothing.
- *
- * A part that is already mounted is left alone. A run hands back what it made
- * rather than making it again, so the same part arrives here on every run of
- * the run that owns it, and binding it twice would put a second copy of the
- * whole child on the page beside the first.
  */
 export declare function bindPart(child: DynamicChild, parent: Node, report?: Report): void;
-/**
- * Reconciles two node lists in place, by node identity.
- *
- * Keyed lists reuse their rows' DOM nodes across reorders, so identity is
- * exactly the right key here: a row that survived is the same node, and only
- * nodes that genuinely moved are touched.
- *
- * The algorithm is a common-prefix/suffix trim, then a longest-increasing-
- * subsequence over the surviving nodes, moving only the ones outside it — the
- * provably minimal number of `insertBefore` calls.
- *
- * This is the outcome of the comparison ADR-0010 required, not an assumption:
- * three candidates were measured over ten operations at two sizes, with the
- * order rotated per repetition and correctness asserted on every run. LIS came
- * out ahead overall (1.02 against 1.17 for the two-ended scan and 1.49 for the
- * naive baseline) and decisively where moves are few and far apart — a swap at
- * 10 000 rows costs it 2 moves instead of 9 997. It loses one case: a full
- * reverse, where the subsequence is length 1 and the analysis buys nothing.
- * That trade is published in `benchmarks/results/reconcilers.json`.
- */
-export declare function reconcile(parent: Node, marker: Node | null, a: Node[], b: Node[]): void;
-export {};
 //# sourceMappingURL=insert.d.ts.map

package/dist/insert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../src/insert.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../src/insert.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAA2C,KAAK,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAExF,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AAIrD,OAAO,EAA6C,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAIvF,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAiB5C;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI,CAO9C;AAED,QAAA,MAAM,IAAI,EAAE,OAAO,MAAiC,CAAC;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,EAAE,OAAO,MAAiC,CAAC;AAE5D;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,EAAE,OAAO,MAAoC,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC9B,CAAC;AAgBF,oEAAoE;AACpE,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,OAAO,GAAG,YAAY,CAEvD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAEnE;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACtB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,MAAM,CACpB,MAAM,EAAE,IAAI,EACZ,KAAK,EAAE,OAAO,EACd,MAAM,GAAE,IAAI,GAAG,IAAW,EAC1B,OAAO,CAAC,EAAE,aAAa,GACtB,IAAI,CA4EN;AAED,yEAAyE;AACzE,MAAM,MAAM,MAAM,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,IAAI,CAAC;AAgD7C;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,IAAI,EACZ,MAAM,EAAE,IAAI,GAAG,IAAI,EACnB,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,OAAO,GACb,SAAS,CAuBX;AAyED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAajF"}

package/dist/internal.d.ts

@@ -12,8 +12,11 @@
 export declare const PROTOCOL_VERSION = 1;
 export { template, path } from './template.js';
 export { first, next } from './claim.js';
-export { insert, applyChild, reconcile, part, store, site, open, close, ran, wrote, cell, writeChild, } from './insert.js';
-export type { DynamicChild, ChildSlot, Slot, Store } from './insert.js';
+export { insert, applyChild, part } from './insert.js';
+export { reconcile } from './reconcile.js';
+export { store, site, open, close, ran, wrote, cell, writeChild } from './store.js';
+export type { DynamicChild, ChildSlot } from './insert.js';
+export type { Slot, Store } from './store.js';
 export { setAttribute, setAttributeNS, setProperty, setBoolean, setClass, setClassList, setStyle, setStyleObject, } from './attributes.js';
 export { on, off } from './events.js';
 export { applyProp, spread, mergeProps, rest } from './props.js';

package/dist/internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EACL,MAAM,EACN,UAAU,EACV,SAAS,EACT,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,GAAG,EACH,KAAK,EACL,IAAI,EACJ,UAAU,GACX,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,EACL,YAAY,EACZ,cAAc,EACd,WAAW,EACX,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,QAAQ,EACR,cAAc,GACf,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACjE,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAGzC,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACpF,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC3D,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EACL,YAAY,EACZ,cAAc,EACd,WAAW,EACX,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,QAAQ,EACR,cAAc,GACf,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACjE,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAGzC,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/internal.dev.js

@@ -19,26 +19,21 @@ import {
   setStyleObject,
   spread,
   view
-} from "./dev-chunk-MKONDKMD.js";
+} from "./dev-chunk-HLMVSIC4.js";
 import {
   applyChild,
-  cell,
-  close,
+  devHandedNewFunction,
   devHydrationMismatch,
+  devRan,
   first,
   hydration,
   insert,
+  isDynamicChild,
   label,
   next,
-  open,
   part,
-  ran,
-  reconcile,
-  site,
-  store,
-  writeChild,
-  wrote
-} from "./dev-chunk-ADHDPKZW.js";
+  reconcile
+} from "./dev-chunk-U46CIJCO.js";
 
 // packages/dom/src/template.ts
 function template(html, isFragment = false) {
@@ -74,6 +69,121 @@ function path(root, ...indices) {
   return node;
 }
 
+// packages/dom/src/store.ts
+import {
+  createOwner,
+  disposeOwner,
+  getOwner,
+  runWithOwner,
+  setOwner,
+  signal
+} from "@firsthandjs/core";
+function store(name = "") {
+  return { slots: [], owner: getOwner(), generation: 0, name };
+}
+function wrote(store2) {
+  store2.busy = true;
+}
+function site(store2, index) {
+  const existing = store2.slots[index];
+  if (existing !== void 0) {
+    existing.seen = store2.generation;
+    return existing;
+  }
+  const slot = { seen: store2.generation };
+  store2.slots[index] = slot;
+  return slot;
+}
+function open(store2, slot) {
+  const owner = createOwner(store2.owner);
+  slot.owner = owner;
+  return setOwner(owner);
+}
+function close(previous) {
+  setOwner(previous);
+}
+function ran(store2, value) {
+  devRan(store2);
+  const generation = store2.generation;
+  const slots = store2.slots;
+  for (let i = 0; i < slots.length; i++) {
+    const slot = slots[i];
+    if (slot === void 0 || slot.seen === generation) {
+      continue;
+    }
+    if (slot.owner !== void 0) {
+      disposeOwner(slot.owner);
+    }
+    slots[i] = void 0;
+  }
+  store2.generation = generation + 1;
+  return value;
+}
+function cell(store2, index, value) {
+  const slot = site(store2, index);
+  const existing = slot.cell;
+  if (existing === void 0) {
+    const made = signal(value);
+    slot.cell = made;
+    return made;
+  }
+  if (existing.peek() !== value) {
+    devHandedNewFunction(store2, value);
+    wrote(store2);
+    existing.value = value;
+  }
+  return existing;
+}
+function writeChild(store2, index, parent, marker, value) {
+  const slot = site(store2, index);
+  if (slot.node === void 0 && hydration.current !== null && adopt(slot, parent, marker, value)) {
+    return;
+  }
+  const type = typeof value;
+  if (type === "string" || type === "number") {
+    const text = String(value);
+    if (text === slot.text) {
+      return;
+    }
+    wrote(store2);
+    slot.text = text;
+    slot.node = applyChild(parent, marker, slot.node ?? null, text);
+    return;
+  }
+  slot.text = void 0;
+  if (value === slot.last) {
+    return;
+  }
+  wrote(store2);
+  slot.last = value;
+  slot.node = applyChild(parent, marker, slot.node ?? null, value);
+}
+function adopt(slot, parent, marker, value) {
+  const claimed = hydration.current.claim(
+    parent,
+    marker
+  );
+  if (claimed === null) {
+    return false;
+  }
+  if (typeof value === "object" && value !== null && isDynamicChild(value)) {
+    slot.last = value;
+    hydration.current.keep(
+      slot,
+      parent,
+      value.anchor,
+      claimed
+    );
+    runWithOwner(value.owner, () => {
+      insert(parent, value.thunk, value.anchor);
+    });
+    return true;
+  }
+  slot.node = claimed.nodes;
+  slot.text = claimed.text;
+  return false;
+}
+
 // packages/dom/src/internal.ts
 import { bind } from "@firsthandjs/core";
 var PROTOCOL_VERSION = 1;

package/dist/internal.js

@@ -1 +1 @@
-import{c as O,d as g,g as E,h as P,i as T,k as w,l as L,m as M,n as j,o as v,p as A,q as F,r as H,s as I,t as R,u as V,v as B,w as D,x as W,y as _}from"./chunk-E4GAI5XA.js";import{a as p,b as i,c as s,d as a,h as d,j as m,k as f,l as c,m as u,n as x,o as y,p as C,q as N,r as h,s as b,u as S}from"./chunk-P4PXTIUD.js";function k(n,l=!1){let t,o;return()=>{let r=i.current;if(r!==null){o??=r.tag(n);let e=r.adopt(o);if(e!==null)return e}if(t===void 0){let e=document.createElement("template");e.innerHTML=n,t=l?e.content:e.content.firstChild}return t.cloneNode(!0)}}function q(n,...l){let t=n;for(let o=0;o<l.length;o++){let r=t.firstChild;for(let e=l[o];e>0;e--)r=r.nextSibling;t=r}return t}import{bind as oe}from"@firsthandjs/core";var Q=1;export{O as COMPONENT,Q as PROTOCOL_VERSION,g as VIEW,b as applyChild,B as applyProp,oe as bind,C as cell,x as close,T as createComponent,s as first,h as insert,E as isComponent,p as label,w as list,W as mergeProps,a as next,M as off,L as on,u as open,d as part,q as path,y as ran,S as reconcile,_ as rest,j as setAttribute,v as setAttributeNS,F as setBoolean,H as setClass,I as setClassList,A as setProperty,R as setStyle,V as setStyleObject,c as site,D as spread,m as store,k as template,P as view,N as writeChild,f as wrote};
+import{c as h,d as b,g as N,h as C,i as O,k as T,l as k,m as j,n as E,o as P,p as F,q as H,r as L,s as M,t as R,u as A,v as D,w as I,x as V,y as W}from"./chunk-MWEKNBIC.js";import{a as x,b as l,c as w,d as y,e as S,i as g,j as a,k as f,l as s}from"./chunk-467WEPXM.js";function q(e,i=!1){let r,n;return()=>{let o=l.current;if(o!==null){n??=o.tag(e);let t=o.adopt(n);if(t!==null)return t}if(r===void 0){let t=document.createElement("template");t.innerHTML=e,r=i?t.content:t.content.firstChild}return r.cloneNode(!0)}}function B(e,...i){let r=e;for(let n=0;n<i.length;n++){let o=r.firstChild;for(let t=i[n];t>0;t--)o=o.nextSibling;r=o}return r}import{createOwner as _,disposeOwner as z,getOwner as G,runWithOwner as J,setOwner as m,signal as K}from"@firsthandjs/core";function Q(e=""){return{slots:[],owner:G(),generation:0,name:e}}function d(e){e.busy=!0}function p(e,i){let r=e.slots[i];if(r!==void 0)return r.seen=e.generation,r;let n={seen:e.generation};return e.slots[i]=n,n}function U(e,i){let r=_(e.owner);return i.owner=r,m(r)}function X(e){m(e)}function Y(e,i){let r=e.generation,n=e.slots;for(let o=0;o<n.length;o++){let t=n[o];t===void 0||t.seen===r||(t.owner!==void 0&&z(t.owner),n[o]=void 0)}return e.generation=r+1,i}function Z(e,i,r){let n=p(e,i),o=n.cell;if(o===void 0){let t=K(r);return n.cell=t,t}return o.peek()!==r&&(d(e),o.value=r),o}function $(e,i,r,n,o){let t=p(e,i);if(t.node===void 0&&l.current!==null&&v(t,r,n,o))return;let c=typeof o;if(c==="string"||c==="number"){let u=String(o);if(u===t.text)return;d(e),t.text=u,t.node=s(r,n,t.node??null,u);return}t.text=void 0,o!==t.last&&(d(e),t.last=o,t.node=s(r,n,t.node??null,o))}function v(e,i,r,n){let o=l.current.claim(i,r);return o===null?!1:typeof n=="object"&&n!==null&&a(n)?(e.last=n,l.current.keep(e,i,n.anchor,o),J(n.owner,()=>{f(i,n.thunk,n.anchor)}),!0):(e.node=o.nodes,e.text=o.text,!1)}import{bind as Ne}from"@firsthandjs/core";var pe=1;export{h as COMPONENT,pe as PROTOCOL_VERSION,b as VIEW,s as applyChild,D as applyProp,Ne as bind,Z as cell,X as close,O as createComponent,w as first,f as insert,N as isComponent,x as label,T as list,V as mergeProps,y as next,j as off,k as on,U as open,g as part,B as path,Y as ran,S as reconcile,W as rest,E as setAttribute,P as setAttributeNS,H as setBoolean,L as setClass,M as setClassList,F as setProperty,R as setStyle,A as setStyleObject,p as site,I as spread,Q as store,q as template,C as view,$ as writeChild,d as wrote};

package/dist/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../src/list.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,YAAY,EAElB,MAAM,mBAAmB,CAAC;AAmC3B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,IAAI,EAAE,MAAM,SAAS,CAAC,EAAE,EACxB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EAC1C,MAAM,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,MAAM,CAAC,KAAK,OAAO,GACtE,MAAM,IAAI,EAAE,CA2Gd"}
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../src/list.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,YAAY,EAElB,MAAM,mBAAmB,CAAC;AAmC3B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,IAAI,EAAE,MAAM,SAAS,CAAC,EAAE,EACxB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EAC1C,MAAM,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,MAAM,CAAC,KAAK,OAAO,GACtE,MAAM,IAAI,EAAE,CAyDd"}

package/dist/nodes.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Putting nodes where they belong, and taking them away again.
+ *
+ * The four calls every child position eventually makes, with the measured
+ * reasons each one is shaped the way it is. Nothing here knows what a part is
+ * or what a run is: it is given a slot's current contents and a node, and it
+ * performs the mutation.
+ */
+/** What a child part currently owns in the DOM. */
+export type ChildSlot = Node | Node[] | null;
+export declare const TEXT_NODE = 3;
+export declare function isNode(value: object): value is Node;
+/**
+ * Removes a node from wherever it currently is.
+ *
+ * Usually that is `parent`, but a node can legitimately have been moved — an
+ * element host relocated in the document, for instance — and disposal must
+ * still clean up rather than throw.
+ */
+export declare function detach(node: Node): void;
+/**
+ * Empties a child slot that is everything its parent has.
+ *
+ * Removing ten thousand rows one at a time is ten thousand mutations, each one
+ * a chance for the engine to do bookkeeping it is about to throw away. When
+ * the slot *is* the parent's content — no marker after it, nothing beside it —
+ * the platform has one call that says so, and it is what clearing a table
+ * actually costs: `removeChild` was 85 % of that scenario before this.
+ *
+ * Falls back to removing them one by one whenever the slot is anything less
+ * than the whole, including when a node has been moved out from under it.
+ */
+export declare function clearIn(parent: Node, marker: Node | null, current: ChildSlot): null;
+export declare function clear(current: ChildSlot): null;
+export declare function single(parent: Node, marker: Node | null, current: ChildSlot, node: Node): Node;
+//# sourceMappingURL=nodes.d.ts.map

package/dist/nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../src/nodes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,mDAAmD;AACnD,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;AAE7C,eAAO,MAAM,SAAS,IAAI,CAAC;AAE3B,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,IAAI,CAEnD;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAKvC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI,CAWnF;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI,CAW9C;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAW9F"}

package/dist/props.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../src/props.ts"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CA8C3E;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAa5E;AAED,+CAA+C;AAC/C,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAM1E;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAazF;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAWzB"}
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../src/props.ts"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CA8B3E;AA+BD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAa5E;AAED,+CAA+C;AAC/C,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAM1E;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAazF;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAWzB"}

package/dist/reconcile.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Two node lists, made the same in the fewest moves (ADR-0010).
+ *
+ * Its own module because it is its own algorithm and its own decision: which
+ * reconciler this is was settled by measurement, the comparison is published
+ * in `benchmarks/results/reconcilers.json`, and changing it means running that
+ * comparison again rather than reading the code around it.
+ */
+/**
+ * Reconciles two node lists in place, by node identity.
+ *
+ * Keyed lists reuse their rows' DOM nodes across reorders, so identity is
+ * exactly the right key here: a row that survived is the same node, and only
+ * nodes that genuinely moved are touched.
+ *
+ * The algorithm is a common-prefix/suffix trim, then a longest-increasing-
+ * subsequence over the surviving nodes, moving only the ones outside it — the
+ * provably minimal number of `insertBefore` calls.
+ *
+ * This is the outcome of the comparison ADR-0010 required, not an assumption:
+ * three candidates were measured over ten operations at two sizes, with the
+ * order rotated per repetition and correctness asserted on every run. LIS came
+ * out ahead overall (1.02 against 1.17 for the two-ended scan and 1.49 for the
+ * naive baseline) and decisively where moves are few and far apart — a swap at
+ * 10 000 rows costs it 2 moves instead of 9 997. It loses one case: a full
+ * reverse, where the subsequence is length 1 and the analysis buys nothing.
+ * That trade is published in `benchmarks/results/reconcilers.json`.
+ */
+export declare function reconcile(parent: Node, marker: Node | null, a: Node[], b: Node[]): void;
+//# sourceMappingURL=reconcile.d.ts.map