nuclo 0.2.34 → 0.2.36

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "nuclo",
 	"private": false,
-	"version": "0.2.34",
+	"version": "0.2.36",
 	"description": "Lightweight, type-safe DOM library with plain mutable state and explicit updates — global tag builders, SSR, hydration, and typed CSS, no virtual DOM, no compiler.",
 	"license": "MIT",
 	"author": "Danilo Celestino de Castro (https://github.com/dan2dev)",
@@ -71,10 +71,10 @@
 		"eslint": "^10.11.0",
 		"globals": "^17.12.0",
 		"jiti": "^2.7.0",
-		"jsdom": "^30.1.0",
+		"jsdom": "^30.1.1",
 		"tsdown": "^0.23.0",
 		"typescript": "^7.0.2",
-		"typescript-eslint": "^8.70.0",
+		"typescript-eslint": "^8.70.1",
 		"vitest": "^5.0.1"
 	},
 	"repository": {

package/dist/bootstrap.d.ts

@@ -1,5 +0,0 @@
-/**
- * Initializes the nuclo runtime by exposing tag builders and utilities.
- */
-export declare function initializeRuntime(): void;
-//# sourceMappingURL=bootstrap.d.ts.map

package/dist/bootstrap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"AASA;;GAEG;AAEH,wBAAgB,iBAAiB,IAAI,IAAI,CAoBxC"}

package/dist/element/attributes.d.ts

@@ -1,6 +0,0 @@
-type AttributeKey<TTagName extends ElementTagName> = keyof ExpandedElementAttributes<TTagName>;
-type AttributeCandidate<TTagName extends ElementTagName> = ExpandedElementAttributes<TTagName>[AttributeKey<TTagName>];
-export declare function applySingleAttribute<TTagName extends ElementTagName>(el: ExpandedElement<TTagName>, key: AttributeKey<TTagName>, raw: AttributeCandidate<TTagName> | undefined, shouldMergeClassName?: boolean): void;
-export declare function applyAttributes<TTagName extends ElementTagName>(element: ExpandedElement<TTagName>, attributes: ExpandedElementAttributes<TTagName>, mergeClassName?: boolean): void;
-export { createReactiveTextNode } from "../update/reactive-text";
-//# sourceMappingURL=attributes.d.ts.map

package/dist/element/attributes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../src/element/attributes.ts"],"names":[],"mappings":"AAcA,KAAK,YAAY,CAAC,QAAQ,SAAS,cAAc,IAAI,MAAM,yBAAyB,CAAC,QAAQ,CAAC,CAAC;AAC/F,KAAK,kBAAkB,CAAC,QAAQ,SAAS,cAAc,IACrD,yBAAyB,CAAC,QAAQ,CAAC,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC;AA0C9D,wBAAgB,oBAAoB,CAAC,QAAQ,SAAS,cAAc,EAClE,EAAE,EAAE,eAAe,CAAC,QAAQ,CAAC,EAC7B,GAAG,EAAE,YAAY,CAAC,QAAQ,CAAC,EAC3B,GAAG,EAAE,kBAAkB,CAAC,QAAQ,CAAC,GAAG,SAAS,EAC7C,oBAAoB,UAAQ,GAC3B,IAAI,CAmFN;AAED,wBAAgB,eAAe,CAAC,QAAQ,SAAS,cAAc,EAC7D,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC,EAClC,UAAU,EAAE,yBAAyB,CAAC,QAAQ,CAAC,EAC/C,cAAc,UAAO,GACpB,IAAI,CAYN;AAED,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/element/class-name.d.ts

@@ -1,6 +0,0 @@
-export declare function initReactiveClassName(el: HTMLElement): void;
-export declare function hasReactiveClassName(el: HTMLElement): boolean;
-export declare function addStaticClasses(el: HTMLElement, className: string): void;
-export declare function mergeReactiveClassName(el: HTMLElement, reactiveClassName: string): void;
-export declare function mergeStaticClassName(el: HTMLElement, newClassName: string): void;
-//# sourceMappingURL=class-name.d.ts.map

package/dist/element/class-name.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"class-name.d.ts","sourceRoot":"","sources":["../../src/element/class-name.ts"],"names":[],"mappings":"AAoCA,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,CAO3D;AAGD,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAE7D;AAGD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAQzE;AAGD,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,GAAG,IAAI,CA+BvF;AAGD,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAWhF"}

package/dist/element/event-attributes.d.ts

@@ -1,5 +0,0 @@
-/** Converts a public camel-cased event attribute to its native IDL property. */
-export declare function eventAttributeToProperty(attribute: string): string | null;
-/** Assigns an event attribute, falling back when the IDL property is absent. */
-export declare function setEventAttribute(element: HTMLElement, property: string, listener: EventListener): void;
-//# sourceMappingURL=event-attributes.d.ts.map

package/dist/element/event-attributes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"event-attributes.d.ts","sourceRoot":"","sources":["../../src/element/event-attributes.ts"],"names":[],"mappings":"AAkBA,gFAAgF;AAChF,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiBzE;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,aAAa,GACtB,IAAI,CA2BN"}

package/dist/element/events.d.ts

@@ -1,46 +0,0 @@
-/**
- * Typed event listener helper.
- *
- * Usage:
- *   button(
- *     "Click",
- *     on("click", (e) => {
- *       // e and currentTarget are inferred from the native event map
- *     })
- *   )
- *
- * Design notes:
- * - Returns a NodeModFn so it can be used like any other modifier.
- * - Produces no child node (returns void in the modifier body).
- * - Provides strong typing of the event object based on the DOM event name.
- * - Stores listener references in a WeakMap to prevent memory leaks.
- * - Listeners are automatically cleaned up when elements are garbage collected.
- */
-type EventListenerOptions = boolean | AddEventListenerOptions;
-/**
- * Remove all listeners of a specific type from an element.
- */
-export declare function removeAllListeners(element: HTMLElement, type?: string): void;
-/**
- * Overload for standard HTMLElement events (strongly typed via lib.dom.d.ts)
- */
-export declare function on<K extends NucloHTMLElementEventName, TTagName extends NucloHTMLElementTagNameForEvent<K> = NucloHTMLElementTagNameForEvent<K>>(type: K, listener: TypedEventListener<HTMLElementTagNameMap[TTagName], NucloHTMLElementEventForName<K>>, options?: EventListenerOptions): NodeModFn<TTagName>;
-/**
- * Fires once, after the element has been created and connected to the live
- * document. Equivalent to `{ onMount: ... }`. May return a cleanup function —
- * equivalent to also registering it with on("destroy", ...).
- *
- * Listed before the generic string overload below on purpose: "mount" is a
- * string too, so a less specific overload earlier would shadow this one.
- */
-export declare function on<TTagName extends ElementTagName = ElementTagName>(type: "mount", listener: MountCallback<HTMLElementTagNameMap[TTagName]>): NodeModFn<TTagName>;
-/** Fires once the element has been removed. Equivalent to `{ onDestroy: ... }`. */
-export declare function on<TTagName extends ElementTagName = ElementTagName>(type: "destroy", listener: DestroyCallback<HTMLElementTagNameMap[TTagName]>): NodeModFn<TTagName>;
-/**
- * Fallback / custom event overload (arbitrary event names or custom event types).
- * Specify a custom event type with the E generic if needed:
- *   on<"my-event", CustomEvent<MyDetail>>("my-event", e => { ... })
- */
-export declare function on<K extends string, E extends Event = Event, TTagName extends ElementTagName = ElementTagName>(type: K, listener: TypedEventListener<HTMLElementTagNameMap[TTagName], E>, options?: EventListenerOptions): NodeModFn<TTagName>;
-export {};
-//# sourceMappingURL=events.d.ts.map

package/dist/element/events.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/element/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH,KAAK,oBAAoB,GAAG,OAAO,GAAG,uBAAuB,CAAC;AAiD9D;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,WAAW,EACpB,IAAI,CAAC,EAAE,MAAM,GACZ,IAAI,CAyCN;AA+CD;;GAEG;AACH,wBAAgB,EAAE,CAChB,CAAC,SAAS,yBAAyB,EACnC,QAAQ,SAAS,+BAA+B,CAAC,CAAC,CAAC,GAAG,+BAA+B,CAAC,CAAC,CAAC,EAExF,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,kBAAkB,CAC1B,qBAAqB,CAAC,QAAQ,CAAC,EAC/B,4BAA4B,CAAC,CAAC,CAAC,CAChC,EACD,OAAO,CAAC,EAAE,oBAAoB,GAC7B,SAAS,CAAC,QAAQ,CAAC,CAAC;AAEvB;;;;;;;GAOG;AACH,wBAAgB,EAAE,CAAC,QAAQ,SAAS,cAAc,GAAG,cAAc,EACjE,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,aAAa,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,GACvD,SAAS,CAAC,QAAQ,CAAC,CAAC;AAEvB,mFAAmF;AACnF,wBAAgB,EAAE,CAAC,QAAQ,SAAS,cAAc,GAAG,cAAc,EACjE,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,eAAe,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,GACzD,SAAS,CAAC,QAAQ,CAAC,CAAC;AAEvB;;;;GAIG;AACH,wBAAgB,EAAE,CAChB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,KAAK,GAAG,KAAK,EACvB,QAAQ,SAAS,cAAc,GAAG,cAAc,EAEhD,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,kBAAkB,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,EAChE,OAAO,CAAC,EAAE,oBAAoB,GAC7B,SAAS,CAAC,QAAQ,CAAC,CAAC"}

package/dist/element/factory-meta.d.ts

@@ -1,25 +0,0 @@
-/**
- * Internal factory metadata.
- *
- * Tag builders return opaque factory closures; the list() template engine
- * needs to see through them (tag name + modifier list) to decide whether a
- * row can be built by cloning a skeleton instead of running the factory.
- * The metadata is attached under symbols so nothing leaks into the public
- * API surface or enumerable properties.
- */
-export declare const FACTORY_TAG: unique symbol;
-export declare const FACTORY_MODS: unique symbol;
-export declare function acquireMetadataOnlyFactory(): () => null;
-export declare function setFactoryMeta(factory: unknown, tag: string, mods: readonly unknown[]): void;
-/** Returns the modifier list of a tag-builder factory, or undefined. */
-export declare function getFactoryMods(fn: unknown): readonly unknown[] | undefined;
-/** Returns the tag name of a tag-builder factory, or undefined. */
-export declare function getFactoryTag(fn: unknown): string | undefined;
-export declare function isMetadataOnlyFactoryMode(): boolean;
-/**
- * Takes the render function and its two args directly (rather than a `() =>`
- * thunk) so the hot per-row call in list/runtime.ts doesn't allocate a
- * closure just to defer a single call.
- */
-export declare function withMetadataOnlyFactories<TItem, T>(fn: (item: TItem, index: number) => T, item: TItem, index: number): T;
-//# sourceMappingURL=factory-meta.d.ts.map

package/dist/element/factory-meta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory-meta.d.ts","sourceRoot":"","sources":["../../src/element/factory-meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,eAA8B,CAAC;AACvD,eAAO,MAAM,YAAY,eAA+B,CAAC;AAiBzD,wBAAgB,0BAA0B,IAAI,MAAM,IAAI,CAKvD;AAOD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,SAAS,OAAO,EAAE,GACvB,IAAI,CAGN;AAED,wEAAwE;AACxE,wBAAgB,cAAc,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,OAAO,EAAE,GAAG,SAAS,CAE1E;AAED,mEAAmE;AACnE,wBAAgB,aAAa,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE7D;AAED,wBAAgB,yBAAyB,IAAI,OAAO,CAEnD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CASxH"}

package/dist/element/factory.d.ts

@@ -1,32 +0,0 @@
-/**
- * Element creation: builds HTML/SVG elements and applies the modifier list
- * that was passed to a tag builder (children, attributes, text, on(), ...).
- */
-import { type NodeModifier } from "./modifiers";
-export type { NodeModifier };
-/**
- * Applies modifiers to an element, appending newly produced Nodes while avoiding
- * duplicate DOM insertions (i.e. only appends if parentNode differs).
- *
- * `localIndex` advances once per appended child so each reactive/static text
- * modifier gets a unique `text-N` marker; it is internal bookkeeping only and
- * is not returned (no production caller consumed the previous result object).
- */
-export declare function applyModifiers<TTagName extends ElementTagName>(element: ExpandedElement<TTagName>, modifiers: ReadonlyArray<NodeModifier<TTagName>>, startIndex?: number): void;
-/**
- * Creates an HTML element with the specified tag name and applies modifiers to it.
- */
-export declare function createHtmlElementWithModifiers<TTagName extends ElementTagName>(tagName: TTagName, modifiers: ReadonlyArray<NodeModifier<TTagName>>): ExpandedElement<TTagName>;
-/**
- * Creates an SVG element with the specified tag name and applies modifiers to it.
- */
-export declare function createSvgElementWithModifiers<TTagName extends keyof SVGElementTagNameMap>(tagName: TTagName, modifiers: ReadonlyArray<unknown>): SVGElementTagNameMap[TTagName];
-/**
- * Creates an HTML tag builder function.
- */
-export declare function createHtmlTagBuilder<TTagName extends ElementTagName>(tagName: TTagName): ExpandedElementBuilder<TTagName>;
-/**
- * Creates an SVG tag builder function.
- */
-export declare function createSvgTagBuilder<TTagName extends keyof SVGElementTagNameMap>(tagName: TTagName): ExpandedSVGElementBuilder<TTagName>;
-//# sourceMappingURL=factory.d.ts.map

package/dist/element/factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/element/factory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAKnE,YAAY,EAAE,YAAY,EAAE,CAAC;AAE7B;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAS,cAAc,EAC5D,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC,EAClC,SAAS,EAAE,aAAa,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,EAChD,UAAU,SAAI,GACb,IAAI,CAoBN;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,QAAQ,SAAS,cAAc,EAC5E,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,aAAa,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,GAC/C,eAAe,CAAC,QAAQ,CAAC,CAO3B;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,SAAS,MAAM,oBAAoB,EACvF,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,aAAa,CAAC,OAAO,CAAC,GAChC,oBAAoB,CAAC,QAAQ,CAAC,CAOhC;AAmED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,SAAS,cAAc,EAClE,OAAO,EAAE,QAAQ,GAChB,sBAAsB,CAAC,QAAQ,CAAC,CAElC;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,SAAS,MAAM,oBAAoB,EAC7E,OAAO,EAAE,QAAQ,GAChB,yBAAyB,CAAC,QAAQ,CAAC,CAErC"}

package/dist/element/inline-style.d.ts

@@ -1,9 +0,0 @@
-type StyleAssignment = CSSStyleObject;
-type StyleResolver = () => StyleAssignment | null | undefined;
-/**
- * Simplified style management - basic functionality with minimal overhead
- */
-export declare function assignInlineStyles<TTagName extends ElementTagName>(element: ExpandedElement<TTagName>, styles: StyleAssignment | null | undefined): void;
-export declare function applyStyleAttribute<TTagName extends ElementTagName>(element: ExpandedElement<TTagName>, styleValue: StyleAssignment | StyleResolver | null | undefined): void;
-export {};
-//# sourceMappingURL=inline-style.d.ts.map

package/dist/element/inline-style.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inline-style.d.ts","sourceRoot":"","sources":["../../src/element/inline-style.ts"],"names":[],"mappings":"AAKA,KAAK,eAAe,GAAG,cAAc,CAAC;AACtC,KAAK,aAAa,GAAG,MAAM,eAAe,GAAG,IAAI,GAAG,SAAS,CAAC;AAE9D;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,SAAS,cAAc,EAChE,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC,EAClC,MAAM,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,GACzC,IAAI,CAeN;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,SAAS,cAAc,EACjE,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC,EAClC,UAAU,EAAE,eAAe,GAAG,aAAa,GAAG,IAAI,GAAG,SAAS,GAC7D,IAAI,CAUN"}

package/dist/element/lifecycle.d.ts

@@ -1,106 +0,0 @@
-/**
- * Mount/destroy lifecycle hooks.
- *
- * Two equivalent ways to register them, both funneling into this module:
- *   - `on("mount", cb)` / `on("destroy", cb)`            (./events.ts)
- *   - `{ onMount: cb }` / `{ onDestroy: cb }` attributes  (./attributes.ts)
- *
- * ── Mount timing ─────────────────────────────────────────────────────────
- * A freshly created element is still detached while its own subtree (and,
- * for the initial page render, every ancestor up to the root) is being
- * assembled — nuclo builds a tree fully off-document before attaching it in
- * one shot (render()/hydrate()), and list()/when() do the same for the
- * rows/branches they insert into an already-connected host. So onMount can't
- * fire the instant a modifier runs; the element is queued and the queue is
- * flushed once the surrounding operation (render(), hydrate(), or update())
- * finishes inserting its nodes — at that point the element is guaranteed
- * connected. See flushMountQueue() and its call sites in render.ts/update.ts.
- *
- * ── Destroy timing ───────────────────────────────────────────────────────
- * onDestroy fires eagerly and synchronously the moment nuclo removes the
- * element through its own machinery — see the disposeElementLifecycle() call
- * in shared/dom.ts's cleanupNodeTree(), which every ordinary removal
- * (list()/when() diffing, any safeRemoveChild() call) already goes through.
- * The handful of fast paths that intentionally skip that per-node walk for
- * performance (list()'s bulk clear/replace, the single-element when()/else()
- * swap) call disposeLifecyclesInSubtree() directly instead, so destroy still
- * fires exactly at removal time there too — without paying for a bookkeeping
- * walk when nothing in the affected subtree ever registered a lifecycle
- * callback (hasActiveLifecycleRegistrations() short-circuits that to a
- * single integer comparison in the — by far most common — case where
- * lifecycle hooks aren't used at all).
- *
- * An element removed through means nuclo never observes (e.g. a raw
- * `node.remove()` on a container built by render()) is only noticed the next
- * time render()/hydrate()/update() runs and finds it disconnected — this
- * file does not use a MutationObserver. That never leaks memory (all
- * bookkeeping below is WeakMap-based, exactly like every other nuclo
- * registry — see test/memory/gc-collectability.test.ts), but if an app
- * removes a node that way and never calls update() again afterwards,
- * onDestroy for it will not run either. This matches list()/when()'s own
- * documented "disconnection is noticed lazily, on the next update()"
- * contract; it is not a lifecycle-specific limitation.
- *
- * ── Ordering (parent/child, any depth) ──────────────────────────────────
- * Neither mechanism below cares how many list()s, when()s, or plain
- * component functions wrap an element — every element gets its own
- * independent WeakMap record, keyed by the element itself, so correctness
- * never depends on nesting depth. What nesting *does* affect is the relative
- * order two related elements' callbacks fire in, which follows normal
- * resource-scoping discipline in both directions:
- *  - onMount fires parent-before-child. This falls out of queue order for
- *    free — a parent's own {onMount}/on("mount", ...) modifier is applied
- *    (queuing it) before the child factories in its own modifier list are
- *    even invoked, since applying modifiers is a synchronous, in-order walk.
- *    A child's onMount can safely assume any context the parent's onMount
- *    set up is already in place.
- *  - onDestroy fires child-before-parent (see cleanupNodeTree() and
- *    disposeLifecyclesInSubtree() in shared/dom.ts, both post-order: they
- *    recurse into every descendant *before* disposing the node itself). A
- *    parent's onDestroy can safely release something its children were
- *    still using — they have already run by the time it does.
- * Together: mount is top-down, destroy is bottom-up — the same order a
- * `try { ... } finally { ... }` stack of nested resource scopes unwinds in,
- * applied to the DOM tree instead of the call stack.
- *
- * ── Memory ───────────────────────────────────────────────────────────────
- * Per-element bookkeeping lives in a WeakMap keyed by the element, so it is
- * collectible the instant nothing else references the element — exactly the
- * same shape as list/runtime.ts's and update/registry.ts's registries. The
- * mountQueue holds only WeakRefs, so abandoned builds are collectible even
- * if no later operation flushes the queue. Completed mount callbacks are
- * released immediately; only their returned cleanup survives until destroy.
- */
-/** Registers a mount callback for `element`. See the module doc for timing. */
-export declare function registerMount<TElement extends Element>(element: TElement, callback: MountCallback<TElement>): void;
-/** Registers a destroy callback for `element`. See the module doc for timing. */
-export declare function registerDestroy<TElement extends Element>(element: TElement, callback: DestroyCallback<TElement>): void;
-/**
- * Flushes every element queued since the last flush, firing its mount
- * callback(s) now that the surrounding render()/hydrate()/update() pass has
- * finished inserting nodes into the (connected) document.
- *
- * Swaps the shared queue out to a local batch before iterating, so a mount
- * callback that itself triggers a nested update() (which pushes onto a fresh
- * queue and flushes it in its own, inner call) can't corrupt or be corrupted
- * by the batch this call is still draining.
- */
-export declare function flushMountQueue(): void;
-/**
- * Finalizes one element's lifecycle: silently cancels a mount that never got
- * to run (state was still Pending — built and discarded within one pass), or
- * fires its destroy callback(s) (state was Mounted). Idempotent — safe to
- * call more than once for the same element, e.g. once eagerly from
- * cleanupNodeTree() and, redundantly, once more from a fast-path caller that
- * doesn't know whether the eager walk already reached this node.
- */
-export declare function disposeElementLifecycle(element: Element): void;
-/**
- * True while at least one element anywhere on the page has a live (Pending
- * or Mounted) lifecycle record. Called by disposeLifecyclesInSubtree() in
- * shared/dom.ts (its own short-circuit) and, hoisted out of its per-row
- * loop, by list/runtime.ts's bulkClearRecords() — so clearing a large
- * lifecycle-free list costs one comparison, not one skipped call per row.
- */
-export declare function hasActiveLifecycleRegistrations(): boolean;
-//# sourceMappingURL=lifecycle.d.ts.map

package/dist/element/lifecycle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/element/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AAsFH,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,QAAQ,SAAS,OAAO,EACpD,OAAO,EAAE,QAAQ,EACjB,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,GAChC,IAAI,CAWN;AAED,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,QAAQ,SAAS,OAAO,EACtD,OAAO,EAAE,QAAQ,EACjB,QAAQ,EAAE,eAAe,CAAC,QAAQ,CAAC,GAClC,IAAI,CAMN;AAkDD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAQtC;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAyB9D;AAED;;;;;;GAMG;AACH,wBAAgB,+BAA+B,IAAI,OAAO,CAEzD"}

package/dist/element/modifiers.d.ts

@@ -1,11 +0,0 @@
-/**
- * Caches the probe result of zero-arity function modifiers so the same
- * function is not re-invoked when it reappears during re-renders.
- */
-export declare const modifierProbeCache: WeakMap<() => unknown, {
-    value: unknown;
-    error: boolean;
-}>;
-export type NodeModifier<TTagName extends ElementTagName = ElementTagName> = NodeMod<TTagName> | NodeModFn<TTagName> | AnyParentNodeModifier;
-export declare function applyNodeModifier<TTagName extends ElementTagName>(parent: ExpandedElement<TTagName>, modifier: NodeModifier<TTagName>, index: number): Node | null;
-//# sourceMappingURL=modifiers.d.ts.map

package/dist/element/modifiers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"modifiers.d.ts","sourceRoot":"","sources":["../../src/element/modifiers.ts"],"names":[],"mappings":"AAcA;;;GAGG;AACH,eAAO,MAAM,kBAAkB,gBAAqB,OAAO;WAAW,OAAO;WAAS,OAAO;EAAK,CAAC;AAEnG,MAAM,MAAM,YAAY,CAAC,QAAQ,SAAS,cAAc,GAAG,cAAc,IACtE,OAAO,CAAC,QAAQ,CAAC,GACjB,SAAS,CAAC,QAAQ,CAAC,GACnB,qBAAqB,CAAC;AAqDzB,wBAAgB,iBAAiB,CAAC,QAAQ,SAAS,cAAc,EAChE,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,EACjC,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,EAChC,KAAK,EAAE,MAAM,GACX,IAAI,GAAG,IAAI,CAsFb"}

package/dist/element/tags.d.ts

@@ -1,5 +0,0 @@
-export declare const HTML_TAGS: readonly ["a", "abbr", "address", "area", "article", "aside", "audio", "b", "base", "bdi", "bdo", "blockquote", "body", "br", "button", "canvas", "caption", "cite", "code", "col", "colgroup", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "iframe", "img", "input", "ins", "kbd", "label", "legend", "li", "link", "main", "map", "mark", "menu", "meta", "meter", "nav", "noscript", "object", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "script", "search", "section", "select", "slot", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track", "u", "ul", "var", "video", "wbr"];
-export declare const SVG_TAGS: readonly ["a", "animate", "animateMotion", "animateTransform", "circle", "clipPath", "defs", "desc", "ellipse", "feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence", "filter", "foreignObject", "g", "image", "line", "linearGradient", "marker", "mask", "metadata", "mpath", "path", "pattern", "polygon", "polyline", "radialGradient", "rect", "script", "set", "stop", "style", "svg", "switch", "symbol", "text", "textPath", "title", "tspan", "use", "view"];
-export declare const SELF_CLOSING_TAGS: readonly ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source", "track", "wbr"];
-export declare function registerGlobalTagBuilders(target?: Record<string, unknown>): void;
-//# sourceMappingURL=tags.d.ts.map

package/dist/element/tags.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../../src/element/tags.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,SAAS,g7BAc4B,CAAC;AAEnD,eAAO,MAAM,QAAQ,4wBAWyC,CAAC;AAE/D,eAAO,MAAM,iBAAiB,iHAGoB,CAAC;AAkDnD,wBAAgB,yBAAyB,CAAC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAc,GAAG,IAAI,CAe5F"}

package/dist/hydration.d.ts

@@ -1,73 +0,0 @@
-/**
- * Hydration context — tracks global hydration state and per-parent cursor positions.
- *
- * During hydration the component tree is built against an existing DOM tree
- * (produced by SSR).  Instead of creating new nodes, factories claim existing
- * children from their parent element by advancing a cursor.
- *
- * The cursor is a *node pointer* (the next unclaimed child), not an index.
- * Indexed childNodes access is O(n) after any tree/attribute mutation in
- * jsdom (live NodeList re-materialization) which made hydration O(n²);
- * firstChild/nextSibling pointers are O(1) in every DOM implementation.
- */
-export declare function isHydrating(): boolean;
-/**
- * True while a tree is being built for SSR serialization (inside
- * renderToString). Text children must keep their `<!-- text-N -->` markers in
- * this mode so the emitted HTML stays hydratable — even when `isBrowser` is
- * true (SSR running under jsdom, or an isomorphic worker that provides a DOM).
- * A pure client render leaves this false and skips the markers.
- */
-export declare function isSerializing(): boolean;
-/**
- * Runs `fn` with serialization mode enabled, restoring the previous state
- * afterwards (so nested/re-entrant renderToString calls behave correctly).
- */
-export declare function runSerializing<T>(fn: () => T): T;
-export declare function startHydration(): void;
-export declare function endHydration(): void;
-/**
- * Runs a callback with hydration temporarily disabled, restoring the previous
- * state afterwards.  Used when a server/client mismatch forces a subtree to be
- * rendered fresh in the middle of a hydration pass — fresh rendering must not
- * claim nodes from the surrounding SSR DOM.
- */
-export declare function runWithoutHydration<T>(fn: () => T): T;
-/**
- * Returns the next unclaimed child of a parent node (or null at the end)
- * without advancing the cursor.
- */
-export declare function peekChild(parent: Node): Node | null;
-/**
- * Sets the cursor to a specific child node (or null for "past the end").
- */
-export declare function setCursor(parent: Node, node: Node | null): void;
-/**
- * Advances the cursor past whitespace-only text nodes.
- *
- * Nuclo's own SSR output never produces bare whitespace text nodes (text
- * children are always preceded by a `<!-- text-N -->` marker), so unmarked
- * whitespace comes from the surrounding template or an HTML
- * formatter/minifier.  Skipping (without removing) keeps the cursor aligned
- * while leaving the document's visual whitespace untouched.
- */
-export declare function skipWhitespaceText(parent: Node): void;
-/**
- * Claims the next child node from parent at the current cursor position.
- * Advances the cursor by one.
- */
-export declare function claimChild(parent: Node): Node | null;
-/**
- * Attempts to claim an existing element from the parent during hydration.
- * Returns the claimed element if the next child matches the expected tag, or null.
- */
-export declare function claimElement(parent: Node, tagName: string): Element | null;
-/**
- * Removes unclaimed SSR children from a hydrated element.
- * Must be called after modifiers have been applied to a claimed element.
- * Removes nodes from the cursor through `lastOriginalChild` (the element's
- * last child before modifiers ran) — nodes appended by modifiers come after
- * that boundary and are preserved.
- */
-export declare function cleanupUnclaimedChildren(node: Node, lastOriginalChild: Node | null): void;
-//# sourceMappingURL=hydration.d.ts.map

package/dist/hydration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hydration.d.ts","sourceRoot":"","sources":["../src/hydration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAQH,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQhD;AAED,wBAAgB,cAAc,IAAI,IAAI,CAMrC;AAED,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQrD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAGnD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAE/D;AAMD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI,CAUrD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAMpD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAQ1E;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CASzF"}

package/dist/index.d.ts

@@ -1,17 +0,0 @@
-export { initializeRuntime } from "./bootstrap";
-export { registerGlobalTagBuilders, HTML_TAGS, SVG_TAGS, SELF_CLOSING_TAGS } from "./element/tags";
-export { createHtmlTagBuilder, createSvgTagBuilder, createHtmlElementWithModifiers, createSvgElementWithModifiers, } from "./element/factory";
-export { applyNodeModifier } from "./element/modifiers";
-export { applyAttributes } from "./element/attributes";
-export { on } from "./element/events";
-export { update } from "./update/update";
-export { scope } from "./update/scope";
-export { list } from "./list";
-export { when } from "./when";
-export { render, hydrate } from "./render";
-export * from "./style";
-export { appendChildren, createComment, createConditionalComment, replaceNodeSafely } from "./shared/dom";
-export { isBoolean, isFunction, isNode, isObject, isPrimitive, isTagLike, isZeroArityFunction } from "./shared/type-guards";
-export { isBrowser } from "./shared/environment";
-import "./bootstrap";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGhD,OAAO,EAAE,yBAAyB,EAAE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnG,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,8BAA8B,EAC9B,6BAA6B,GAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAGtC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAG3C,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC1G,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC5H,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGjD,OAAO,aAAa,CAAC"}

package/dist/list/index.d.ts

@@ -1,7 +0,0 @@
-import type { ListRenderer, ListItemsProvider } from "./types";
-/**
- * Maps items to DOM elements, keeping them in sync with changes.
- * Returns a function compatible with both HTML and SVG contexts.
- */
-export declare function list<TItem, TTagName extends ElementTagName = ElementTagName>(itemsProvider: ListItemsProvider<TItem>, render: ListRenderer<TItem, TTagName>): ListModifier<TTagName>;
-//# sourceMappingURL=index.d.ts.map

package/dist/list/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/list/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE/D;;;GAGG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,QAAQ,SAAS,cAAc,GAAG,cAAc,EAC1E,aAAa,EAAE,iBAAiB,CAAC,KAAK,CAAC,EACvC,MAAM,EAAE,YAAY,CAAC,KAAK,EAAE,QAAQ,CAAC,GACpC,YAAY,CAAC,QAAQ,CAAC,CAOxB"}

package/dist/list/runtime.d.ts

@@ -1,6 +0,0 @@
-import type { ListRenderer, ListRuntime, ListItemsProvider } from "./types";
-import type { UpdateScope } from "../update/scope";
-export declare function sync<TItem, TTagName extends ElementTagName>(runtime: ListRuntime<TItem, TTagName>): void;
-export declare function createListRuntime<TItem, TTagName extends ElementTagName = ElementTagName>(itemsProvider: ListItemsProvider<TItem>, renderItem: ListRenderer<TItem, TTagName>, host: ExpandedElement<TTagName>, index: number): ListRuntime<TItem, TTagName>;
-export declare function updateListRuntimes(scope?: UpdateScope): void;
-//# sourceMappingURL=runtime.d.ts.map

package/dist/list/runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/list/runtime.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAkC,iBAAiB,EAAmB,MAAM,SAAS,CAAC;AAC7H,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAsSnD,wBAAgB,IAAI,CAAC,KAAK,EAAE,QAAQ,SAAS,cAAc,EACzD,OAAO,EAAE,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,GACpC,IAAI,CA0ON;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,QAAQ,SAAS,cAAc,GAAG,cAAc,EACvF,aAAa,EAAE,iBAAiB,CAAC,KAAK,CAAC,EACvC,UAAU,EAAE,YAAY,CAAC,KAAK,EAAE,QAAQ,CAAC,EACzC,IAAI,EAAE,eAAe,CAAC,QAAQ,CAAC,EAC/B,KAAK,EAAE,MAAM,GACZ,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,CAM9B;AAoKD,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,EAAE,WAAW,GAAG,IAAI,CAuD5D"}

package/dist/list/template.d.ts

@@ -1,113 +0,0 @@
-/**
- * Row-template cloning for list().
- *
- * Building a row through the normal pipeline costs one createElement + a full
- * modifier pass per element. For a keyed list every row comes from the same
- * render function, so the structure is identical across rows and only the
- * leaves differ (text values, event handlers, reactive resolvers, and —
- * rarely — static attribute values). This module:
- *
- *  1. analyzes the first row's factory tree (via the internal factory
- *     metadata symbols) and, when every modifier falls into a supported
- *     shape, records a slot program for the row;
- *  2. clones the first row's built element as a skeleton (cloneNode does not
- *     copy property-assigned `on*` handlers or reactive registrations, and
- *     reactive classNames are scrubbed so a selected first row can't leak
- *     its state into the skeleton);
- *  3. builds every other row as skeleton.cloneNode(true) + a patch pass that
- *     walks the new factory tree in lockstep with the slot program.
- *
- * Any construct outside the supported shape (style objects, on() modifiers,
- * nested list()/when(), node children, resolvers returning non-primitives,
- * multiple className sources per element, SVG) bails to the normal build
- * path — the template is per-list state, so unsupported lists simply never
- * activate it. A per-row shape mismatch (heterogeneous render output)
- * deactivates the template for that list and rebuilds the row normally.
- */
-export declare const LEAF_TEXT = 0;
-export declare const LEAF_CLASSNAME = 1;
-/**
- * A clone's dynamic leaf, owned by its list record instead of the global
- * reactive registries: template rows have a known lifetime (they live and die
- * with their record), so update() can flush them with a tight array walk —
- * no WeakRef/WeakMap bookkeeping per row, nothing for the GC sweeps to prune.
- */
-export interface RowLeaf {
-    kind: number;
-    node: Text | HTMLElement;
-    fn: () => unknown;
-    last: string;
-}
-export declare const SLOT_ATTRS = 0;
-export declare const SLOT_TEXT = 1;
-export declare const SLOT_REACTIVE_TEXT = 2;
-export declare const SLOT_CHILD = 3;
-export declare const SLOT_NULL = 4;
-export declare const ATTR_STATIC = 0;
-export declare const ATTR_EVENT = 1;
-export declare const ATTR_REACTIVE_CLASSNAME = 2;
-export declare const ATTR_NULL = 3;
-export interface AttrSpec {
-    key: string;
-    kind: number;
-    /** Static attrs: element exposes the key as a property (filled from the skeleton). */
-    prop: boolean;
-    /** Static attrs: first-row value. Events: normalized native property name. */
-    value?: unknown;
-}
-export type TemplateSlot = {
-    kind: typeof SLOT_ATTRS;
-    keys: AttrSpec[];
-} | {
-    kind: typeof SLOT_TEXT;
-} | {
-    kind: typeof SLOT_REACTIVE_TEXT;
-} | {
-    kind: typeof SLOT_CHILD;
-    child: TemplateNode;
-} | {
-    kind: typeof SLOT_NULL;
-};
-export interface TemplateNode {
-    tag: string;
-    slots: TemplateSlot[];
-}
-export interface ListTemplate {
-    tmpl: TemplateNode;
-    skeleton: Element;
-}
-/**
- * Classifies a factory's modifier tree into a slot program, or returns null
- * when any modifier falls outside the supported shape.
- */
-export declare function analyzeFactory(tag: string, mods: readonly unknown[]): TemplateNode | null;
-/**
- * One-time skeleton pass: fills each static attr's property-vs-attribute
- * flag and scrubs reactive classNames (the first row may have rendered with
- * row-specific state, e.g. a selected row's "danger" class).
- */
-export declare function prepareSkeleton(tmpl: TemplateNode, skeleton: Element): void;
-/**
- * Patches a skeleton clone from a fresh factory tree. Returns false on any
- * shape mismatch — the caller then rebuilds the row through the normal path
- * (a partially patched clone is safe to abandon: its reactive registrations
- * are weak and disconnected, so the next update() sweeps them).
- */
-export declare function instantiateTemplate(tmpl: TemplateNode, mods: readonly unknown[], el: Element, leaves: RowLeaf[]): boolean;
-/**
- * Converts the normally-built first row of a compatible template into the same
- * record-owned dynamic leaf representation used by skeleton clones.
- *
- * The normal builder has already registered reactive text/className leaves in
- * the global registries. Template rows have a tighter lifetime through their
- * list record, so unregister those first-row leaves and let updateListRuntimes()
- * flush them with the rest of the templated rows.
- */
-export declare function adoptTemplateLeaves(tmpl: TemplateNode, mods: readonly unknown[], el: Element, leaves: RowLeaf[]): boolean;
-/**
- * Flushes a template row's dynamic leaves: re-evaluates each resolver and
- * writes the DOM only on change. Resolver errors leave the previous value in
- * place (matching the notify passes' error tolerance).
- */
-export declare function flushRowLeaves(leaves: RowLeaf[]): void;
-//# sourceMappingURL=template.d.ts.map

package/dist/list/template.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/list/template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAQH,eAAO,MAAM,SAAS,IAAI,CAAC;AAC3B,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,IAAI,GAAG,WAAW,CAAC;IACzB,EAAE,EAAE,MAAM,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,SAAS,IAAI,CAAC;AAC3B,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,SAAS,IAAI,CAAC;AAE3B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,SAAS,IAAI,CAAC;AAE3B,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,sFAAsF;IACtF,IAAI,EAAE,OAAO,CAAC;IACd,8EAA8E;IAC9E,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,OAAO,UAAU,CAAC;IAAC,IAAI,EAAE,QAAQ,EAAE,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,OAAO,SAAS,CAAA;CAAE,GAC1B;IAAE,IAAI,EAAE,OAAO,kBAAkB,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,OAAO,UAAU,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,OAAO,SAAS,CAAA;CAAE,CAAC;AAE/B,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,YAAY,GAAG,IAAI,CAqFzF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CA8B3E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,SAAS,OAAO,EAAE,EACxB,EAAE,EAAE,OAAO,EACX,MAAM,EAAE,OAAO,EAAE,GAChB,OAAO,CAiHT;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,SAAS,OAAO,EAAE,EACxB,EAAE,EAAE,OAAO,EACX,MAAM,EAAE,OAAO,EAAE,GAChB,OAAO,CAwET;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAuBtD"}