export { A as AttrSpec, a as attr } from './attrSelector-Cmu2ZoGO.js';
export { D as DelegateOptions, d as delegate, a as delegateCapture } from './delegate-CL9VTZFb.js';
import { ArraySignal } from './array-signal.js';
import { SafeHtml } from './jsx-runtime.js';
export { Fragment, isSafeHtml, raw } from './jsx-runtime.js';
export { M as MountResult, m as mount } from './mount-Bo2qOx25.js';
import { Signal } from '@preact/signals-core';
export { ReadonlySignal, Signal, batch, computed } from '@preact/signals-core';
export { S as Store, d as defineStore, r as resetAllStores } from './testing-DNEY7wi3.js';
import './bindings-CYwoJpQb.js';

/**
 * Re-exports of `@preact/signals-core`. Lets the rest of the codebase depend
 * on `'./reactive.js'` without naming the underlying lib, so swapping it out
 * later (or fronting it with a hand-rolled implementation) is a one-file
 * change.
 *
 * Two dev hook slots sit in front of the bare re-exports:
 *
 * - `signalFactory` replaces the constructor so writes to never-subscribed
 *   signals can warn (`KERF_DEV_WARN_UNTRACKED_SIGNALS=1`).
 *
 * - `wrapEffect` wraps the user body so `delegate()` can detect that it's
 *   running inside an effect (`KERF_DEV_WARN_DELEGATE_IN_EFFECT=1`).
 *
 * Both are `undefined` unless the consumer imported `kerfjs/dev`, so production
 * sees the bare `@preact/signals-core` exports behind one property read.
 *
 * ORDERING: `signalFactory` is resolved at signal-CREATION time, so signals
 * created before `kerfjs/dev` is installed stay plain and the untracked-signal
 * warning never sees them. Static imports hoist above a `await import()`, so a
 * module-scope signal in an imported module is created first. See
 * docs/11-dev-warnings.md for the install-ordering rules.
 */

declare function signal<T>(value?: T): Signal<T>;
declare function effect(fn: () => void | (() => void)): () => void;

/**
 * `each(items, render, cacheKey?)` — keyed list iteration with per-item memoization.
 *
 * Drops in as the body of a list-rendering JSX expression inside a `mount()`
 * render function. Returns a `SafeHtml` carrying a structured list segment,
 * so `mount()` can run a native keyed reconciler instead of the general-
 * purpose morph for these children.
 *
 * Two layers of optimization:
 *
 * 1. Per-item memoization. `render(item)` is skipped for items whose object
 *    identity (and optional `cacheKey`) are unchanged since the previous
 *    call. Their HTML strings come from a `WeakMap` keyed by item reference.
 *    The immutable-update style ("replace the row object" instead of "mutate
 *    it") is the idiomatic way to invalidate a row and is what the memo is
 *    built around. A same-ref `arraySignal.update()` (mutate the object and
 *    return it) also works — it bumps a per-item content version (KF-418,
 *    `item-version.ts`) that the memo checks — so it re-renders the row in
 *    every consumer, not just the list that drained the patch.
 *
 * 2. Structural handoff. `mount()` recognizes the list segment and bypasses
 *    the parse-the-whole-table round trip: only fresh items get parsed (one
 *    at a time, into the smallest detached element), and only changed rows
 *    get patched in the live DOM. Unchanged rows are physically the same
 *    nodes they were before — never visited.
 *
 * `cacheKey` is a passive comparator — it covers the case where external
 * state, not the item itself, drives what the row should render (e.g. a
 * "currently selected" id flips a CSS class on one row). Same item identity
 * but a different `cacheKey` return value means "the cached HTML is stale —
 * re-render this row." Not a reactive subscription: it's evaluated once per
 * mount-effect run and compared against the previous run's return value. If
 * you don't pass `cacheKey`, only object-identity changes invalidate the
 * cache. (Renamed from `key` for clarity — it shared a name with React's
 * `key` prop but has different semantics; the new name says what the
 * parameter actually does. Positional callers — the canonical form — are
 * unaffected.)
 *
 * Items must be objects (cache is a `WeakMap`); wrap primitives if you need
 * to iterate them. Each item's render output must produce exactly one
 * top-level element — the list reconciler binds one live DOM node per item.
 */

/**
 * Options for `each()`. Supplied in place of the bare `cacheKey` third
 * argument, which remains supported.
 */
interface EachOptions<T> {
    /**
     * Passive per-item comparator — the same value the bare third argument
     * takes. Invalidates an item's cached HTML when external state changes what
     * the row should render.
     */
    cacheKey?: (item: T, index: number) => unknown;
    /**
     * A stable identity for THIS list, unique within the mount.
     *
     * Without one, a list is identified by its call order ("the n-th `each()`
     * this render"), so any render that changes how many `each()` calls run
     * before it reassigns its identity — and the list is rebuilt from scratch,
     * losing row nodes, focus, scroll position and in-progress IME. Give a key
     * to any list that can be preceded by a conditional list.
     *
     * Keyed lists also do not consume a call-order slot, so keying a
     * *conditional* list additionally stabilizes its unkeyed siblings.
     */
    key?: string;
}
declare function each<T extends object>(items: readonly T[] | ArraySignal<T>, render: (item: T, index: number) => SafeHtml | string, cacheKey?: (item: T, index: number) => unknown): SafeHtml;
declare function each<T extends object>(items: readonly T[] | ArraySignal<T>, render: (item: T, index: number) => SafeHtml | string, options?: EachOptions<T>): SafeHtml;

/**
 * `morph(liveRoot, template)` — minimum-mutation DOM reconciliation.
 *
 * Public primitive (KF-150): one-shot reconciliation against an
 * already-populated element. `mount()` first paints by writing
 * `innerHTML`; `morph()` is the "I have a live tree and a template,
 * reconcile them in place" sibling. Use it for SSR hydration of static
 * fragments, page-refresh diffs, third-party widget remounts, etc.
 *
 * Replaces our previous dependency on `morphdom`. The algorithm is the
 * classic two-tree walk: match children by key (id, then data-key, then
 * positional same-tag), morph matches in place, insert / remove / clone
 * the rest. Specialized for what kerf needs:
 *
 * - `childrenOnly` is always true; the live root is never replaced.
 * - Per-element short-circuits: `data-morph-skip` (library-owned, leave
 *   element AND subtree verbatim), `data-morph-skip-children` (KF-152 —
 *   morph attrs on the element, leave its subtree verbatim — for
 *   client-hydrated slots whose loading/state classes still need to flow
 *   through), and `isEqualNode` (byte-identical, no work needed).
 * - **`data-morph-preserve`** protects a node at ITS OWN level only — an
 *   ancestor the template drops still takes the whole subtree, preserved
 *   descendants included (KF-386: intended, but easy to over-read, so it is
 *   pinned by tests and stated in docs/4-render.md §4.3).
 * - **`data-morph-preserve`** (KF-151) is honored in the trailing-removal
 *   pass: an unmatched live element with this attribute is skipped instead
 *   of removed. Lets imperatively-injected nodes (autoplay `<video>`s,
 *   tour-widget tooltips, analytics pixels) survive across renders without
 *   having to `data-morph-skip` the entire parent.
 * - **`ownedItems`** is the set of element nodes owned by an `each()`
 *   list reconciler. The morph skips them in every children walk —
 *   they're not added to the keyed-lookup map, the from-cursor advances
 *   past them, and the trailing-removal pass leaves them in place. This
 *   lets each() coexist with non-list siblings inside the same parent
 *   (KF-102 round 2): the morph still walks the parent's children to
 *   reconcile siblings, but never disturbs list rows. The parameter is an
 *   internal coordination channel between `mount()` and the reconciler;
 *   public callers should omit it (the default empty set is correct for
 *   any tree that isn't being managed by an active `mount()`).
 * - Focused text inputs (`<input>`/`<textarea>`) keep their value +
 *   selection across the morph; focused `[contenteditable]` keeps its
 *   entire subtree (typed content + caret + multi-range selection).
 *
 * Algorithm credit: based on the design of
 * https://github.com/patrick-steele-idem/morphdom by Patrick Steele-Idem
 * (MIT licensed). Reimplemented here so kerf can specialize the hot paths
 * (segment-aware list dispatch, lighter callback surface) and drop the
 * runtime dependency. Original copyright preserved in `LICENSE`.
 */

/**
 * Reconcile the children of `liveRoot` to match `template`.
 *
 * `template` can be an `Element` (used directly), a `SafeHtml`, or a raw
 * HTML string — the latter two are stringified and parsed into a transient
 * element whose tag matches `liveRoot`. The active text-entry / focused-
 * contenteditable preservation rules apply in all cases.
 *
 * `ownedItems` is an internal coordination channel for `mount()`'s list
 * reconciler; public callers should omit it.
 */
declare function morph(liveRoot: Element, template: Element | SafeHtml | string, ownedItems?: ReadonlySet<Element>): void;

/**
 * `renderDocument(node)` — prepend the doctype to a rendered document.
 *
 * Every kerf SSR app ends its routes with the identical concat
 * `"<!DOCTYPE html>" + page.toString()`. This is that one line, blessed, so the
 * doctype isn't reinvented (or forgotten) per route.
 *
 *   import { renderDocument } from 'kerfjs';
 *   return c.html(renderDocument(<Page />));   // "<!DOCTYPE html><html>…"
 *
 * `node` is a `SafeHtml` (from JSX / the `html` tagged template) or a raw string
 * — both are stringified via `.toString()`. The optional `doctype` overrides the
 * default `'html'`.
 */

/** Options for {@link renderDocument}. */
interface RenderDocumentOptions {
    /** The doctype name. Default `'html'` → `<!DOCTYPE html>`. */
    doctype?: string;
}
/** Prepend `<!DOCTYPE …>` to a rendered `SafeHtml` (or string) document and return the full HTML string. */
declare function renderDocument(node: SafeHtml | string, options?: RenderDocumentOptions): string;

/**
 * `toElement(jsx)` — JSX → DOM, with SVG-aware namespace handling.
 *
 * Single-root inputs return an `Element`. Multi-root inputs (text + element,
 * `<><svg/> label</>`, two icons side by side, …) return a `DocumentFragment`
 * containing every top-level node. The DOM insertion APIs (`appendChild`,
 * `replaceChildren`, `append`) inline a `DocumentFragment`'s children on
 * insert, so `parent.replaceChildren(toElement(<>{ICON} label</>))` does the
 * obvious thing — parent gets the svg AND the text, no silent loss.
 *
 * The returned node is always adopted into the live `document` before it's
 * handed back (see `adopt()` below) — never left owned by the inert
 * `<template>`/`DOMParser` document it was parsed in, which is unsafe to mutate
 * before insertion on some engines.
 *
 * SVG namespacing: the HTML5 parser handles `<svg>` as foreign content
 * correctly even when wrapped in a fragment, so multi-root inputs containing
 * SVGs come out namespaced correctly via the `<template>.innerHTML` path. For
 * single-root SVG inputs the XML parser is preferred (stricter — catches
 * malformed markup the HTML5 parser would silently auto-correct). For orphan
 * SVG-namespace fragments without an `<svg>` wrapper (`<path/>`, `<g>`, …)
 * the input is wrapped in `<svg xmlns=...>` and XML-parsed.
 */

declare function toElement(jsx: SafeHtml | string): Element | DocumentFragment;

export { type RenderDocumentOptions, SafeHtml, each, effect, morph, renderDocument, signal, toElement };