nuclo 0.2.34 → 0.2.36

package/dist/style/engine.d.ts

@@ -1,94 +0,0 @@
-/**
- * Shared generated-CSS engine state.
- *
- * One stylesheet, one rule registry, shared by every `createCss` instance so
- * identical declarations dedupe globally and cascade order stays deterministic:
- * base rules first (insertion order), then one grouping rule per at-rule query
- * in registration order (theme `screens` order).
- *
- * Browser: rules are injected through CSSOM with O(1) appends — no rescans.
- * SSR: rules accumulate in the registry; `getCssText()` serializes them.
- *
- * The state below lives on `globalThis`, keyed by a `Symbol.for(...)` (the
- * global symbol registry, shared by every realm-local copy of this module).
- * `nuclo` publishes `.`, `./ssr`, and `./polyfill` as independently built
- * bundle files (see tsdown.config.ts) — a consumer that resolves them
- * through normal package resolution (any bundler/runtime that doesn't
- * alias every subpath to this same source file) loads two or three
- * separate copies of this module, each with its own module-scope
- * variables. Without a realm-wide singleton, `css()` (from `nuclo`) would
- * mint rules into one copy's registry while `getCssText()`/
- * `setSSRCollector()` (from `nuclo/ssr`) read an entirely different,
- * always-empty one — SSR output would render the right classes with no
- * matching CSS at all. Storing the registry on `globalThis` instead makes
- * every copy of this module share the same state regardless of how many
- * times it ends up bundled.
- *
- * The registry never shrinks on its own: atomCache/atomMeta/rawKeys/
- * baseRules/queryRules retain every rule for the life of the process —
- * content-addressed dedup needs a durable record of what each class means,
- * and the engine has no way to know whether a minted class still backs a
- * live DOM node (it's deliberately decoupled from element/list lifecycle),
- * so it can't safely evict. Only resetStyles() (a manual test helper)
- * clears it. This is fine for the intended use — a bounded design-token
- * vocabulary — but a caller piping truly per-instance dynamic values
- * through css({ raw: {...} }) (e.g. per-row data in a list) mints one
- * permanent class per unique value; prefer the `style` prop
- * (element/inline-style.ts) for values that vary per instance rather than
- * per design token. See test/style/registry-growth.test.ts.
- */
-type SSRCollector = (rule: string) => void;
-export interface BlockMeta {
-    readonly query: string | undefined;
-    readonly suffix: string;
-    readonly decls: ReadonlyArray<readonly [string, string]>;
-    /** Author-supplied identity from `css(name, …)`; inherited by cx() merges. */
-    readonly name: string | undefined;
-}
-export declare function setSSRCollector(fn: SSRCollector | null): void;
-/** Pre-register at-rule queries so their cascade order follows theme order. */
-export declare function registerQueries(queries: Iterable<string>): void;
-/**
- * Returns the live stylesheet, (re)binding when the document changes — e.g.
- * fresh jsdom documents between tests. Rebinding replays the whole registry,
- * which replaces v1's per-call classExistsInDOM() DOM scans with a single
- * replay per document.
- */
-export declare function ensureSheet(): CSSStyleSheet | null;
-/**
- * Content-addressed ~42-bit hash (two interleaved FNV-1a style passes). Class
- * names must match between server and client for SSR hydration, so a counter
- * is not an option; 42 bits keeps collision odds low (~1e-5 at 10k
- * unique declaration blocks).
- */
-export declare function hash(input: string): string;
-export declare function expandAmpersands(input: string, replacement: string): string;
-/**
- * One class per (query, selector-suffix) — every declaration that shares that
- * context compiles into a single rule under a single generated class name,
- * rather than one class per individual property. Pass `name` to give the
- * style a stable, readable identity (see mintBlock).
- */
-export declare function atomBlock(query: string | undefined, suffix: string, decls: ReadonlyArray<readonly [string, string]>, name?: string, exactName?: boolean): string;
-/**
- * Merge two same-context generated classes into one: `second`'s declarations
- * override `first`'s per exact property (shorthand/longhand interplay is left
- * to CSS order), and the combined block mints its own content-addressed class
- * — so cx(base, override) keeps base's untouched properties instead of
- * dropping the whole base class. Deterministic: the same pair always yields
- * the same class name, on server and client alike. A named base passes its
- * name down as a prefix, so `cx(appRoot, active)` reads as `app-root-1a2b3c`.
- */
-export declare function mergeBlocks(first: string, second: string): string;
-/** Conflict key (query|suffix) for a generated class — lets cx() group classes by selector context. */
-export declare function conflictKeyOf(className: string): string | undefined;
-/** Current registry generation, used to invalidate per-instance WeakMap hits after resetStyles(). */
-export declare function getStyleEpoch(): number;
-/** Register a non-atomic rule (keyframes, global styles) once per dedupe key. */
-export declare function addRawRule(dedupeKey: string, rule: string): void;
-/** All generated CSS — base rules first, then at-rule groups in registration order. */
-export declare function getCssText(): string;
-/** Clear all engine state (test helper). Removes the injected style element. */
-export declare function resetStyles(): void;
-export {};
-//# sourceMappingURL=engine.d.ts.map

package/dist/style/engine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/style/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAIH,KAAK,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;AAE3C,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACzD,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAkED,wBAAgB,eAAe,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAG7D;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAK/D;AAkJD;;;;;GAKG;AACH,wBAAgB,WAAW,IAAI,aAAa,GAAG,IAAI,CAoDlD;AA+BD;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAS1C;AAWD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAsB3E;AAkGD;;;;;GAKG;AACH,wBAAgB,SAAS,CACxB,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC/C,IAAI,CAAC,EAAE,MAAM,EACb,SAAS,UAAQ,GACf,MAAM,CAER;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAYjE;AAED,uGAAuG;AACvG,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAInE;AAED,qGAAqG;AACrG,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAQhE;AAED,uFAAuF;AACvF,wBAAgB,UAAU,IAAI,MAAM,CASnC;AAED,gFAAgF;AAChF,wBAAgB,WAAW,IAAI,IAAI,CAkBlC"}

package/dist/style/index.d.ts

@@ -1,3 +0,0 @@
-export { createCss, css, cx, variants, keyframes, globalStyle, type ClassInput, type CssInstance, type CSSProperties, type FlatStyle, type KeyframeFrames, type KeyframeStop, type Size, type Style, type StyleResult, type ThemeConfig, type VariantDefinitions, type VariantProps, type VariantsConfig, type VariantsFn, } from "./css";
-export { getCssText, resetStyles, setSSRCollector } from "./engine";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/style/index.ts"],"names":[],"mappings":"AACA,OAAO,EACN,SAAS,EACT,GAAG,EACH,EAAE,EACF,QAAQ,EACR,SAAS,EACT,WAAW,EACX,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,IAAI,EACT,KAAK,KAAK,EACV,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,UAAU,GACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC"}

package/dist/update/conditional.d.ts

@@ -1,3 +0,0 @@
-import type { UpdateScope } from "./scope";
-export declare function updateConditionalElements(scope?: UpdateScope): void;
-//# sourceMappingURL=conditional.d.ts.map

package/dist/update/conditional.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"conditional.d.ts","sourceRoot":"","sources":["../../src/update/conditional.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAuD3C,wBAAgB,yBAAyB,CAAC,KAAK,CAAC,EAAE,WAAW,GAAG,IAAI,CAiBnE"}

package/dist/update/reactive-attributes.d.ts

@@ -1,45 +0,0 @@
-import type { UpdateScope } from "./scope";
-import type { AttributeResolver } from "./registry";
-/**
- * Registers a reactive attribute resolver for an element.
- *
- * The resolver will be called whenever reactive updates run (e.g. via `update()`),
- * or when an `"update"` event is dispatched on the element (or a descendant),
- * allowing attributes to reactively update based on application state.
- *
- * @param element - The DOM element to make reactive
- * @param key - The attribute name being made reactive (e.g., 'class', 'style', 'disabled')
- * @param resolver - Function that returns the new attribute value
- * @param applyValue - Callback that applies the resolved value to the element
- *
- * @example
- * ```ts
- * const isActive = signal(false);
- * const button = document.createElement('button');
- * registerAttributeResolver(
- *   button,
- *   'class',
- *   () => isActive.value ? 'active' : 'inactive',
- *   (value) => button.className = String(value)
- * );
- * ```
- */
-export declare function registerAttributeResolver<TTagName extends ElementTagName>(element: ExpandedElement<TTagName>, key: string, resolver: AttributeResolver, applyValue: (value: unknown) => void): void;
-/**
- * Updates all registered reactive elements by re-evaluating their attribute resolvers.
- *
- * Iterates through all reactive elements and triggers their registered attribute resolvers
- * to update. Automatically cleans up disconnected elements and their event listeners.
- *
- * This function should be called after state changes to synchronize element attributes
- * with application state.
- *
- * @example
- * ```ts
- * // After updating application state
- * isActive.value = true;
- * notifyReactiveElements(); // All reactive attributes update
- * ```
- */
-export declare function notifyReactiveElements(scope?: UpdateScope): void;
-//# sourceMappingURL=reactive-attributes.d.ts.map

package/dist/update/reactive-attributes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reactive-attributes.d.ts","sourceRoot":"","sources":["../../src/update/reactive-attributes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,KAAK,EAAE,iBAAiB,EAAgD,MAAM,YAAY,CAAC;AA+ElG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,SAAS,cAAc,EACvE,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC,EAClC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,iBAAiB,EAC3B,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACnC,IAAI,CA4BN;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,CAAC,EAAE,WAAW,GAAG,IAAI,CAwBhE"}

package/dist/update/reactive-text.d.ts

@@ -1,38 +0,0 @@
-import type { UpdateScope } from "./scope";
-import type { TextResolver } from "./registry";
-/**
- * Creates a reactive text node that automatically updates when its resolver function changes.
- *
- * The text node will be registered for reactive updates and its content will be synchronized
- * whenever notifyReactiveTextNodes() is called.
- *
- * @param resolver - Function that returns the text content (string, number, boolean, etc.)
- * @param preEvaluated - Optional pre-evaluated value to avoid calling resolver immediately
- * @returns A Text node that will reactively update its content
- *
- * @example
- * ```ts
- * const count = signal(0);
- * const textNode = createReactiveTextNode(() => `Count: ${count.value}`);
- * // Later, when count changes and notifyReactiveTextNodes() is called,
- * // the text content automatically updates
- * ```
- */
-export declare function createReactiveTextNode(resolver: TextResolver, preEvaluated?: unknown, sanitize?: boolean): Text | DocumentFragment;
-/**
- * Updates all registered reactive text nodes.
- *
- * Iterates through all reactive text nodes, re-evaluates their resolver functions,
- * and updates their content if it has changed. Automatically cleans up disconnected nodes.
- *
- * This function should be called after state changes to synchronize the DOM with application state.
- *
- * @example
- * ```ts
- * // After updating application state
- * count.value++;
- * notifyReactiveTextNodes(); // All reactive text nodes update
- * ```
- */
-export declare function notifyReactiveTextNodes(scope?: UpdateScope): void;
-//# sourceMappingURL=reactive-text.d.ts.map

package/dist/update/reactive-text.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reactive-text.d.ts","sourceRoot":"","sources":["../../src/update/reactive-text.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,YAAY,EAAE,YAAY,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,gBAAgB,CAgClI;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,CAAC,EAAE,WAAW,GAAG,IAAI,CA0CjE"}

package/dist/update/registry.d.ts

@@ -1,116 +0,0 @@
-/**
- * Shared types and registries for reactive nodes.
- * Single source of truth — imported by reactiveText.ts and reactiveAttributes.ts.
- *
- * Registry structure: the iteration sets only hold WeakRefs; the actual info
- * records live in WeakMaps keyed by the node. Info records may strongly
- * reference the node (e.g. attribute applyValue closures capture the
- * element), so storing them in a strongly-held map would pin the node in
- * memory forever. With WeakMap storage the whole record is collectible as
- * soon as the node is unreachable.
- *
- * Dead WeakRefs left in the iteration sets are pruned by the notify passes as
- * they iterate (deref() === undefined, or node disconnected). Registration is
- * the hottest path in list-heavy renders (one text node + often one element
- * per row), so no per-node FinalizationRegistry is used here: its register()
- * cost per row outweighs keeping the sets tidy between updates, and a stale
- * husk is just an empty WeakRef until the next update() sweeps it.
- */
-export type TextResolver = () => Primitive;
-export interface ReactiveTextNodeInfo {
-    resolver: TextResolver;
-    lastValue: string;
-    /**
-     * DSL semantics: nullish and non-primitive resolver results render as ""
-     * (instead of String(value)). Set by the tag-builder text path so it can
-     * register the user's resolver directly rather than allocating a
-     * sanitizing wrapper closure per text node.
-     */
-    sanitize?: boolean;
-}
-export type AttributeResolver = () => unknown;
-export interface AttributeResolverRecord {
-    key: string;
-    resolver: AttributeResolver;
-    applyValue: (value: unknown) => void;
-    lastValue: unknown;
-}
-export interface ReactiveElementInfo {
-    /**
-     * Flat keyed array rather than a Map: elements almost always carry one or
-     * two reactive attributes, so linear key lookup on registration beats a Map
-     * allocation per element, and the per-update flush iterates with a plain
-     * index loop (no iterator/destructuring allocations).
-     */
-    attributeResolvers: AttributeResolverRecord[];
-}
-/**
- * Iteration set of weak references to reactive text nodes.
- */
-export declare const reactiveTextNodes: Set<WeakRef<Text>>;
-/**
- * WeakMap for O(1) lookups of reactive text node info by node reference.
- */
-export declare const reactiveTextNodesByNode: WeakMap<Text, {
-    ref: WeakRef<Text>;
-    info: ReactiveTextNodeInfo;
-}>;
-/**
- * Iteration set of weak references to reactive elements.
- */
-export declare const reactiveElements: Set<WeakRef<Element>>;
-/**
- * WeakMap for O(1) lookups of reactive element info by element reference.
- */
-export declare const reactiveElementsByNode: WeakMap<Element, {
-    ref: WeakRef<Element>;
-    info: ReactiveElementInfo;
-}>;
-/**
- * Registers a reactive text node in both lookup structures.
- */
-export declare function registerReactiveTextNode(node: Text, info: ReactiveTextNodeInfo): void;
-/**
- * Registers a reactive element in both lookup structures.
- */
-export declare function registerReactiveElement(element: Element, info: ReactiveElementInfo): void;
-/**
- * Removes a reactive text node's WeakRef entry from the iteration set.
- */
-export declare function removeReactiveTextNodeRef(ref: WeakRef<Text>): void;
-/**
- * Removes a reactive element's WeakRef entry from the iteration set.
- */
-export declare function removeReactiveElementRef(ref: WeakRef<Element>): void;
-/**
- * Manually removes reactive text node info for a specific text node.
- * This should be called when a text node is removed from the DOM to prevent memory leaks.
- */
-export declare function cleanupReactiveTextNode(node: Text): void;
-/**
- * Manually removes reactive element info for a specific element.
- * This should be called when an element is removed from the DOM to prevent memory leaks.
- */
-export declare function cleanupReactiveElement(element: Element): void;
-export interface ConditionalInfo<TTagName extends ElementTagName = ElementTagName> {
-    condition: () => boolean;
-    tagName: TTagName;
-    modifiers: Array<NodeMod<TTagName> | NodeModFn<TTagName>>;
-    isSvg: boolean;
-}
-/**
- * Attach conditional info to a node and register it.
- */
-export declare function storeConditionalInfo<TTagName extends ElementTagName>(node: Node, info: ConditionalInfo<TTagName>): void;
-/**
- * Explicit unregister helper (optional use on teardown if needed).
- * O(1) via reverse lookup WeakMap.
- */
-export declare function unregisterConditionalNode(node: Node): void;
-/**
- * Returns an array of currently tracked conditional nodes that are still alive.
- * Automatically cleans up garbage-collected nodes.
- */
-export declare function getActiveConditionalNodes(): Node[];
-export declare function getConditionalInfo(node: Node): ConditionalInfo<ElementTagName> | null;
-//# sourceMappingURL=registry.d.ts.map

package/dist/update/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/update/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,YAAY,GAAG,MAAM,SAAS,CAAC;AAE3C,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,YAAY,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC;AAE9C,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACrC,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,kBAAkB,EAAE,uBAAuB,EAAE,CAAC;CAC/C;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,oBAA2B,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,uBAAuB;SAA4B,OAAO,CAAC,IAAI,CAAC;UAAQ,oBAAoB;EAAK,CAAC;AAE/G;;GAEG;AACH,eAAO,MAAM,gBAAgB,uBAA8B,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,sBAAsB;SAA+B,OAAO,CAAC,OAAO,CAAC;UAAQ,mBAAmB;EAAK,CAAC;AAEnH;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAYrF;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,mBAAmB,GAAG,IAAI,CASzF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAElE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAEpE;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAMxD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAM7D;AAOD,MAAM,WAAW,eAAe,CAAC,QAAQ,SAAS,cAAc,GAAG,cAAc;IAChF,SAAS,EAAE,MAAM,OAAO,CAAC;IACzB,OAAO,EAAE,QAAQ,CAAC;IAClB,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC1D,KAAK,EAAE,OAAO,CAAC;CACf;AAyBD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,SAAS,cAAc,EACnE,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,eAAe,CAAC,QAAQ,CAAC,GAC7B,IAAI,CAON;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAQ1D;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,EAAE,CAalD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,eAAe,CAAC,cAAc,CAAC,GAAG,IAAI,CAErF"}

package/dist/update/scope.d.ts

@@ -1,7 +0,0 @@
-export interface UpdateScope {
-    roots: ReadonlyArray<Element>;
-    contains(node: Node): boolean;
-}
-export declare function getScopeRoots(ids: readonly string[]): Element[];
-export declare function scope<TTagName extends ElementTagName = ElementTagName>(...ids: string[]): NodeModFn<TTagName>;
-//# sourceMappingURL=scope.d.ts.map

package/dist/update/scope.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../src/update/scope.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;CAC/B;AAoCD,wBAAgB,aAAa,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,EAAE,CAoC/D;AAED,wBAAgB,KAAK,CAAC,QAAQ,SAAS,cAAc,GAAG,cAAc,EACpE,GAAG,GAAG,EAAE,MAAM,EAAE,GACf,SAAS,CAAC,QAAQ,CAAC,CAQrB"}

package/dist/update/update.d.ts

@@ -1,4 +0,0 @@
-import type { UpdateScope } from "./scope";
-export declare function update(...scopeIds: string[]): void;
-export declare function dispatchGlobalUpdateEvent(scope?: UpdateScope): void;
-//# sourceMappingURL=update.d.ts.map

package/dist/update/update.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../src/update/update.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAY3C,wBAAgB,MAAM,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAiClD;AAED,wBAAgB,yBAAyB,CAAC,KAAK,CAAC,EAAE,WAAW,GAAG,IAAI,CAqBnE"}

package/dist/when/builder.d.ts

@@ -1,16 +0,0 @@
-import type { WhenCondition, WhenContent, WhenGroup } from "./runtime";
-declare class WhenBuilderImpl<TTagName extends ElementTagName = ElementTagName> {
-    private groups;
-    private elseContent;
-    constructor(initialCondition: WhenCondition, ...content: WhenContent<TTagName>[]);
-    cloneWith(additionalGroup?: WhenGroup<TTagName>, newElseContent?: WhenContent<TTagName>[]): WhenBuilderImpl<TTagName>;
-    when(condition: WhenCondition, ...content: WhenContent<TTagName>[]): WhenBuilderImpl<TTagName>;
-    else(...content: WhenContent<TTagName>[]): WhenBuilderImpl<TTagName>;
-    render(host: ExpandedElement<TTagName>, index: number): Node | null;
-    private freshRender;
-    private hydrateRender;
-    private createRuntimeFromMarkers;
-}
-export declare function createWhenBuilderFunction<TTagName extends ElementTagName>(builder: WhenBuilderImpl<TTagName>): WhenBuilder<TTagName>;
-export { WhenBuilderImpl };
-//# sourceMappingURL=builder.d.ts.map

package/dist/when/builder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/when/builder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,SAAS,EAAe,MAAM,WAAW,CAAC;AAyBpF,cAAM,eAAe,CAAC,QAAQ,SAAS,cAAc,GAAG,cAAc;IACpE,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,WAAW,CAA+B;IAElD,YAAY,gBAAgB,EAAE,aAAa,EAAE,GAAG,OAAO,EAAE,WAAW,CAAC,QAAQ,CAAC,EAAE,EAE/E;IAED,SAAS,CACP,eAAe,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,EACrC,cAAc,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,EAAE,GACvC,eAAe,CAAC,QAAQ,CAAC,CAM3B;IAED,IAAI,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,OAAO,EAAE,WAAW,CAAC,QAAQ,CAAC,EAAE,GAAG,eAAe,CAAC,QAAQ,CAAC,CAG7F;IAED,IAAI,CAAC,GAAG,OAAO,EAAE,WAAW,CAAC,QAAQ,CAAC,EAAE,GAAG,eAAe,CAAC,QAAQ,CAAC,CAGnE;IAED,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAUlE;IAED,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,aAAa;IAgFrB,OAAO,CAAC,wBAAwB;CAwBjC;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,SAAS,cAAc,EACvE,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC,GACjC,WAAW,CAAC,QAAQ,CAAC,CAavB;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/when/index.d.ts

@@ -1,44 +0,0 @@
-import type { WhenCondition, WhenContent } from "./runtime";
-export { updateWhenRuntimes } from "./runtime";
-/**
- * Creates a conditional rendering block (when/else logic).
- *
- * Renders different content based on boolean conditions, similar to if/else statements.
- * Conditions can be static booleans or reactive functions that are re-evaluated on updates.
- *
- * @param condition - Boolean value or function returning a boolean
- * @param content - Content to render when condition is true
- * @returns A builder that allows chaining additional .when() or .else() branches
- *
- * @example
- * ```ts
- * const isLoggedIn = signal(false);
- *
- * div(
- *   when(() => isLoggedIn.value,
- *     span('Welcome back!')
- *   )
- *   .else(
- *     button('Login', on('click', () => login()))
- *   )
- * )
- * ```
- *
- * @example
- * ```ts
- * // Multiple conditions
- * div(
- *   when(() => status.value === 'loading',
- *     spinner()
- *   )
- *   .when(() => status.value === 'error',
- *     errorMessage()
- *   )
- *   .else(
- *     contentView()
- *   )
- * )
- * ```
- */
-export declare function when<TTagName extends ElementTagName = ElementTagName>(condition: WhenCondition, ...content: WhenContent<TTagName>[]): WhenBuilder<TTagName>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/when/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,IAAI,CAAC,QAAQ,SAAS,cAAc,GAAG,cAAc,EACnE,SAAS,EAAE,aAAa,EACxB,GAAG,OAAO,EAAE,WAAW,CAAC,QAAQ,CAAC,EAAE,GAClC,WAAW,CAAC,QAAQ,CAAC,CAGvB"}

package/dist/when/runtime.d.ts

@@ -1,59 +0,0 @@
-import type { UpdateScope } from "../update/scope";
-export type WhenCondition = boolean | (() => boolean);
-export type WhenContent<TTagName extends ElementTagName = ElementTagName> = NodeModLike<TTagName>;
-export interface WhenGroup<TTagName extends ElementTagName = ElementTagName> {
-    condition: WhenCondition;
-    content: WhenContent<TTagName>[];
-}
-export interface WhenRuntime<TTagName extends ElementTagName = ElementTagName> {
-    startMarker: Comment;
-    endMarker: Comment;
-    host: ExpandedElement<TTagName>;
-    index: number;
-    groups: WhenGroup<TTagName>[];
-    elseContent: WhenContent<TTagName>[];
-    /**
-     * Tracks which branch is currently rendered:
-     *  - null:  nothing rendered yet (initial state)
-     *  - -1:    else branch is active
-     *  - >= 0:  groups[activeIndex] is active
-     */
-    activeIndex: number | null;
-    update(): void;
-}
-/**
- * Evaluates which condition branch should be active.
- * Returns the index of the first truthy condition, -1 for else branch, or null for no match.
- */
-export declare function evaluateActiveCondition<TTagName extends ElementTagName>(groups: ReadonlyArray<WhenGroup<TTagName>>, elseContent: ReadonlyArray<WhenContent<TTagName>>): number | null;
-/**
- * Main render function for when/else conditionals.
- * Evaluates conditions, clears old content, and renders the active branch.
- */
-export declare function renderWhenContent<TTagName extends ElementTagName>(runtime: WhenRuntime<TTagName>): void;
-/**
- * Registers a when runtime for tracking and updates.
- * Uses WeakRef to prevent memory leaks when elements are removed.
- * The runtime object itself is mutable and will be updated in place.
- */
-export declare function registerWhenRuntime<TTagName extends ElementTagName>(runtime: WhenRuntime<TTagName>): void;
-/**
- * Updates all active when/else conditional runtimes.
- *
- * Re-evaluates all conditional branches and re-renders if the active branch has changed.
- * Automatically cleans up runtimes that are garbage collected or disconnected from DOM.
- *
- * This function should be called after state changes that affect conditional expressions.
- *
- * @example
- * ```ts
- * isLoggedIn.value = true;
- * updateWhenRuntimes(); // All when() conditionals re-evaluate
- * ```
- */
-export declare function updateWhenRuntimes(scope?: UpdateScope): void;
-/**
- * Renders a list of content items and collects the resulting nodes.
- */
-export declare function renderContentItems<TTagName extends ElementTagName>(items: ReadonlyArray<WhenContent<TTagName>>, host: ExpandedElement<TTagName>, index: number, endMarker: Comment): Node[];
-//# sourceMappingURL=runtime.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/when/runtime.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAKnD,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,CAAC;AACtD,MAAM,MAAM,WAAW,CAAC,QAAQ,SAAS,cAAc,GAAG,cAAc,IACtE,WAAW,CAAC,QAAQ,CAAC,CAAC;AAExB,MAAM,WAAW,SAAS,CAAC,QAAQ,SAAS,cAAc,GAAG,cAAc;IACzE,SAAS,EAAE,aAAa,CAAC;IACzB,OAAO,EAAE,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,WAAW,CAAC,QAAQ,SAAS,cAAc,GAAG,cAAc;IAC3E,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;IAC9B,WAAW,EAAE,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;IACrC;;;;;OAKG;IACH,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,IAAI,IAAI,CAAC;CAChB;AAmBD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,SAAS,cAAc,EACrE,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,EAC1C,WAAW,EAAE,aAAa,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,GAChD,MAAM,GAAG,IAAI,CAOf;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,SAAS,cAAc,EAC/D,OAAO,EAAE,WAAW,CAAC,QAAQ,CAAC,GAC7B,IAAI,CAoBN;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,SAAS,cAAc,EACjE,OAAO,EAAE,WAAW,CAAC,QAAQ,CAAC,GAC7B,IAAI,CAKN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,EAAE,WAAW,GAAG,IAAI,CA0C5D;AA8BD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,SAAS,cAAc,EAChE,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,EAC3C,IAAI,EAAE,eAAe,CAAC,QAAQ,CAAC,EAC/B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,GACjB,IAAI,EAAE,CASR"}