vlist 1.9.1 → 2.0.0

package/dist/core/scroll.js

@@ -0,0 +1,137 @@
+/**
+ * vlist v2 — Scroll Handling
+ *
+ * Wheel interception for synchronous rendering, scroll idle detection,
+ * and smooth scroll animation.
+ */
+import { SCROLL_IDLE_TIMEOUT, WHEEL_SENSITIVITY, SCROLL_EASING } from "../constants";
+export function createScrollHandler(config) {
+    const { state, viewport, horizontal, wheelEnabled, onFrame, onIdle } = config;
+    const idleTimeout = config.idleTimeout || SCROLL_IDLE_TIMEOUT;
+    const target = config.scrollTarget ?? viewport;
+    let idleTimer = null;
+    let animationId = null;
+    // ── Scroll event (passive, for native/touch scrolling) ──────────
+    function onScrollEvent() {
+        const pos = horizontal ? viewport.scrollLeft : viewport.scrollTop;
+        if (Math.abs(pos - state.scrollPosition) < 0.5)
+            return;
+        state.prevScrollPosition = state.scrollPosition;
+        state.scrollPosition = pos;
+        state.scrollDirection = pos > state.prevScrollPosition ? 1 : pos < state.prevScrollPosition ? -1 : 0;
+        onFrame();
+        scheduleIdle();
+    }
+    // ── Wheel event (non-passive, synchronous rendering) ────────────
+    function onWheelEvent(event) {
+        if (state.isCompressed)
+            return;
+        let next;
+        if (horizontal) {
+            if (Math.abs(event.deltaX) > Math.abs(event.deltaY))
+                return;
+            const current = viewport.scrollLeft;
+            const max = viewport.scrollWidth - viewport.clientWidth;
+            next = Math.max(0, Math.min(current + event.deltaY * WHEEL_SENSITIVITY, max));
+            if (Math.abs(next - current) < 1)
+                return;
+            event.preventDefault();
+            viewport.scrollLeft = next;
+        }
+        else {
+            const crossOverflow = viewport.scrollWidth > viewport.clientWidth;
+            if (crossOverflow && Math.abs(event.deltaX) > Math.abs(event.deltaY))
+                return;
+            if (crossOverflow && event.deltaX !== 0) {
+                event.preventDefault();
+                viewport.scrollLeft += event.deltaX;
+            }
+            const current = viewport.scrollTop;
+            const max = viewport.scrollHeight - viewport.clientHeight;
+            next = Math.max(0, Math.min(current + event.deltaY * WHEEL_SENSITIVITY, max));
+            if (Math.abs(next - current) < 1)
+                return;
+            event.preventDefault();
+            viewport.scrollTop = next;
+        }
+        state.prevScrollPosition = state.scrollPosition;
+        state.scrollPosition = next;
+        state.scrollDirection = next > state.prevScrollPosition ? 1 : -1;
+        onFrame();
+        scheduleIdle();
+    }
+    // ── Idle detection ──────────────────────────────────────────────
+    function scheduleIdle() {
+        if (idleTimer !== null)
+            clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+            idleTimer = null;
+            state.scrollDirection = 0;
+            onIdle();
+        }, idleTimeout);
+    }
+    // ── Smooth scroll animation ─────────────────────────────────────
+    function cancelScroll() {
+        if (animationId !== null) {
+            cancelAnimationFrame(animationId);
+            animationId = null;
+        }
+    }
+    function smoothScrollTo(target, duration, setFn, easing = SCROLL_EASING) {
+        cancelScroll();
+        const from = state.scrollPosition;
+        if (Math.abs(target - from) < 1) {
+            if (setFn)
+                setFn(target);
+            else if (horizontal)
+                viewport.scrollLeft = target;
+            else
+                viewport.scrollTop = target;
+            return;
+        }
+        const start = performance.now();
+        function tick(now) {
+            const elapsed = now - start;
+            const t = Math.min(elapsed / duration, 1);
+            const pos = from + (target - from) * easing(t);
+            if (setFn)
+                setFn(pos);
+            else if (horizontal)
+                viewport.scrollLeft = pos;
+            else
+                viewport.scrollTop = pos;
+            if (!setFn)
+                state.scrollPosition = pos;
+            onFrame();
+            if (t < 1) {
+                animationId = requestAnimationFrame(tick);
+            }
+            else {
+                animationId = null;
+            }
+        }
+        animationId = requestAnimationFrame(tick);
+    }
+    // ── Public interface ────────────────────────────────────────────
+    return {
+        attach() {
+            target.addEventListener("scroll", onScrollEvent, { passive: true });
+            if (wheelEnabled) {
+                target.addEventListener("wheel", onWheelEvent, { passive: false });
+            }
+        },
+        detach() {
+            target.removeEventListener("scroll", onScrollEvent);
+            if (wheelEnabled) {
+                target.removeEventListener("wheel", onWheelEvent);
+            }
+            cancelScroll();
+            if (idleTimer !== null) {
+                clearTimeout(idleTimer);
+                idleTimer = null;
+            }
+        },
+        cancelScroll,
+        smoothScrollTo,
+    };
+}

package/dist/core/sizes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * vlist v2 — Size Cache
+ *
+ * Float64Array prefix sums with O(1) offset lookups and O(log n) binary search.
+ */
+export { createSizeCache, countVisibleItems, countItemsFittingFromBottom, getOffsetForVirtualIndex, } from "../rendering/sizes";
+export type { SizeCache } from "../rendering/sizes";
+//# sourceMappingURL=sizes.d.ts.map

package/dist/core/sizes.js

@@ -0,0 +1,6 @@
+/**
+ * vlist v2 — Size Cache
+ *
+ * Float64Array prefix sums with O(1) offset lookups and O(log n) binary search.
+ */
+export { createSizeCache, countVisibleItems, countItemsFittingFromBottom, getOffsetForVirtualIndex, } from "../rendering/sizes";

package/dist/core/state.d.ts

@@ -0,0 +1,47 @@
+/**
+ * vlist v2 — EngineState
+ *
+ * Persistent singleton instantiated once during createVList().
+ * All hot-path state lives in pre-allocated TypedArrays.
+ * Phase 1 mutates in place. Phase 2 reads directly. Zero allocation.
+ */
+export interface EngineState {
+    /** Data indices of visible items — Phase 1 writes, Phase 2 reads */
+    visibleIndices: Int32Array;
+    /** Pixel offsets along main axis for each visible item */
+    visibleOffsets: Float64Array;
+    /** Sizes along main axis for each visible item */
+    visibleSizes: Float64Array;
+    /** Number of valid entries in the buffers (0 = empty range sentinel) */
+    visibleCount: number;
+    /** First data index in the visible window (contiguous layouts) */
+    startIndex: number;
+    /** Total content size in pixels */
+    totalSize: number;
+    /** Current buffer capacity */
+    capacity: number;
+    scrollPosition: number;
+    prevScrollPosition: number;
+    /** 1 = forward, -1 = backward, 0 = idle */
+    scrollDirection: number;
+    containerSize: number;
+    crossSize: number;
+    totalItems: number;
+    prevRangeStart: number;
+    prevRangeEnd: number;
+    renderPending: boolean;
+    initialized: boolean;
+    destroyed: boolean;
+    isCompressed: boolean;
+    compressionRatio: number;
+    prevAriaTotal: number;
+    /**
+     * Resize buffers when container changes. Cold path only.
+     * Heuristic: capacity = ceil(containerSize / minItemSize) + overscan * 2
+     */
+    resizeCapacity(containerSize: number, minItemSize: number, overscan?: number): void;
+    /** Reset to empty range sentinel. */
+    clear(): void;
+}
+export declare function createEngineState(initialCapacity: number): EngineState;
+//# sourceMappingURL=state.d.ts.map

package/dist/core/state.js

@@ -0,0 +1,56 @@
+/**
+ * vlist v2 — EngineState
+ *
+ * Persistent singleton instantiated once during createVList().
+ * All hot-path state lives in pre-allocated TypedArrays.
+ * Phase 1 mutates in place. Phase 2 reads directly. Zero allocation.
+ */
+import { OVERSCAN } from "../constants";
+export function createEngineState(initialCapacity) {
+    const state = {
+        visibleIndices: new Int32Array(initialCapacity),
+        visibleOffsets: new Float64Array(initialCapacity),
+        visibleSizes: new Float64Array(initialCapacity),
+        visibleCount: 0,
+        startIndex: 0,
+        totalSize: 0,
+        capacity: initialCapacity,
+        scrollPosition: 0,
+        prevScrollPosition: 0,
+        scrollDirection: 0,
+        containerSize: 0,
+        crossSize: 0,
+        totalItems: 0,
+        prevRangeStart: 0,
+        prevRangeEnd: -1,
+        renderPending: false,
+        initialized: false,
+        destroyed: false,
+        isCompressed: false,
+        compressionRatio: 1,
+        prevAriaTotal: -1,
+        resizeCapacity(containerSize, minItemSize, overscan = OVERSCAN) {
+            if (minItemSize <= 0 || containerSize <= 0)
+                return;
+            const needed = Math.ceil(containerSize / minItemSize) + overscan * 2;
+            if (needed <= state.capacity)
+                return;
+            const newCapacity = needed + 8;
+            const newIndices = new Int32Array(newCapacity);
+            const newOffsets = new Float64Array(newCapacity);
+            const newSizes = new Float64Array(newCapacity);
+            newIndices.set(state.visibleIndices);
+            newOffsets.set(state.visibleOffsets);
+            newSizes.set(state.visibleSizes);
+            state.visibleIndices = newIndices;
+            state.visibleOffsets = newOffsets;
+            state.visibleSizes = newSizes;
+            state.capacity = newCapacity;
+        },
+        clear() {
+            state.visibleCount = 0;
+            state.startIndex = 0;
+        },
+    };
+    return state;
+}

package/dist/core/types.d.ts

@@ -0,0 +1,187 @@
+/**
+ * vlist v2 — Core Type Definitions
+ *
+ * Zero-allocation pipeline types. All hot-path state lives in TypedArrays
+ * on the EngineState singleton — no intermediate object allocation.
+ */
+import type { VListItem, ItemTemplate, ItemState } from "../types";
+import type { SizeCache } from "./sizes";
+import type { EngineState } from "./state";
+import type { Emitter } from "../events";
+/** Phase 1 hook — mutates EngineState in place, zero allocation */
+export type CalculateHook = (state: EngineState) => void;
+/** Phase 2 hook — runs after DOM commit */
+export type CommitHook = (state: EngineState) => void;
+/** After-scroll hook — runs after both phases complete */
+export type AfterScrollHook = (scrollPosition: number, direction: number) => void;
+/** Idle hook — runs when scrolling stops */
+export type IdleHook = () => void;
+/** Resize hook — runs on container resize (cold path) */
+export type ResizeHook = (width: number, height: number) => void;
+export interface CompiledHooks {
+    readonly calculate: readonly CalculateHook[];
+    readonly commit: readonly CommitHook[];
+    readonly afterScroll: readonly AfterScrollHook[];
+    readonly idle: readonly IdleHook[];
+    readonly resize: readonly ResizeHook[];
+}
+export interface ResolvedConfig {
+    readonly overscan: number;
+    readonly horizontal: boolean;
+    readonly reverse: boolean;
+    readonly classPrefix: string;
+    readonly interactive: boolean;
+    readonly mainAxisPadding: number;
+    readonly crossAxisPadding: number;
+    readonly startPadding: number;
+    readonly endPadding: number;
+    readonly crossPadStart: number;
+    readonly crossPadEnd: number;
+    readonly striped: boolean | "data" | "even" | "odd";
+    readonly gap: number;
+}
+export interface DOMStructure {
+    readonly root: HTMLElement;
+    readonly viewport: HTMLElement;
+    readonly content: HTMLElement;
+    readonly liveRegion: HTMLElement;
+}
+export interface ElementPool {
+    acquire(): HTMLElement;
+    release(element: HTMLElement): void;
+    readonly size: number;
+    clear(): void;
+}
+export type VisibleRangeFn = (scrollPosition: number, containerSize: number, sizeCache: SizeCache, totalItems: number, outStart: {
+    value: number;
+}, outEnd: {
+    value: number;
+}) => void;
+export interface PluginContext<T extends VListItem = VListItem> {
+    readonly dom: DOMStructure;
+    readonly sizeCache: SizeCache;
+    readonly pool: ElementPool;
+    readonly config: ResolvedConfig;
+    readonly emitter: Emitter<import("../types").VListEvents<T>>;
+    readonly template: ItemTemplate<T>;
+    registerMethod(name: string, fn: Function): void;
+    getMethod(name: string): Function | undefined;
+    registerClickHandler(handler: (event: MouseEvent) => void): void;
+    registerKeydownHandler(handler: (event: KeyboardEvent) => void): void;
+    registerDestroyHandler(handler: () => void): void;
+    setSizeConfig(config: number | ((index: number) => number)): void;
+    setVisibleRangeFn(fn: VisibleRangeFn): void;
+    setScrollFns(get: () => number, set: (pos: number) => void): void;
+    setVirtualTotalFn(fn: () => number): void;
+    getItems(): readonly T[];
+    getItem(index: number): T | undefined;
+    getState(): EngineState;
+    rebuildSizeCache(): void;
+    updateContentSize(size: number): void;
+    setRenderFn(renderIfNeeded: () => void, forceRender: () => void): void;
+    renderIfNeeded(): void;
+    forceRender(): void;
+    setGetItemFn(fn: (index: number) => T | undefined): void;
+    setItemStateFn(fn: (index: number, state: ItemState) => void): void;
+    getItemStateFn(): ((index: number, state: ItemState) => void) | null;
+    readonly rawSizeSpec: number | ((index: number, ...args: unknown[]) => number);
+    scrollTo(position: number): void;
+    smoothScrollTo(position: number, duration: number, easing?: (t: number) => number): void;
+    disableDefaultScroll(): void;
+    disableDefaultResize(): void;
+    setScrollTarget(target: EventTarget): void;
+    setScrollToPosFn(fn: (index: number, sizeCache: import("./sizes").SizeCache, containerSize: number, totalItems: number, align: string) => number): void;
+    setScrollToIndexFn(fn: (index: number, align: string, behavior?: string, duration?: number, easing?: (t: number) => number) => void | false): void;
+    onScrollFrame(): void;
+    onScrollIdle(): void;
+    removeItemById(id: string | number): number;
+    insertItemAt(item: T, index: number): void;
+    setRemoveItemFn(fn: (id: string | number) => number): void;
+    setInsertItemFn(fn: (item: T, index: number) => void): void;
+    setUpdateItemFn(fn: (id: string | number, updates: Partial<T>) => boolean): void;
+    getRenderedElement(index: number): HTMLElement | null;
+    setNavConfig(config: {
+        total?: () => number;
+        ud?: number;
+        lr?: number;
+        scrollIndex?: (itemIndex: number) => number;
+        navigate?: (currentIndex: number, key: string, total: number) => number;
+    }): void;
+    getNavConfig(): {
+        ud: number;
+        lr: number;
+        scrollIndex: ((itemIndex: number) => number) | null;
+        navigate: ((currentIndex: number, key: string, total: number) => number) | null;
+    };
+}
+export interface VListPlugin<T extends VListItem = VListItem> {
+    readonly name: string;
+    readonly priority?: number;
+    readonly conflicts?: readonly string[];
+    /** Cold path: one-time wiring during createVList(). */
+    setup?(ctx: PluginContext<T>): void;
+    /** Hot path: compiled into linear arrays, iterated per frame. */
+    hooks?: {
+        onCalculate?(state: EngineState): void;
+        onCommit?(state: EngineState): void;
+        onAfterScroll?(scrollPosition: number, direction: number): void;
+        onIdle?(): void;
+        onResize?(width: number, height: number): void;
+    };
+    /** Cleanup on destroy. */
+    destroy?(): void;
+}
+export interface VList<T extends VListItem = VListItem> {
+    readonly element: HTMLElement;
+    readonly items: readonly T[];
+    readonly total: number;
+    setItems(items: T[]): void;
+    appendItems(items: T[]): void;
+    prependItems(items: T[]): void;
+    updateItem(id: string | number, updates: Partial<T>): void;
+    insertItem(item: T, index?: number): void;
+    removeItem(id: string | number): void;
+    removeItems(ids: ReadonlyArray<string | number>): number;
+    getItemAt(index: number): T | undefined;
+    getIndexById(id: string | number): number;
+    scrollToIndex(index: number, align?: "start" | "center" | "end" | {
+        align?: "start" | "center" | "end";
+        behavior?: "auto" | "smooth";
+        duration?: number;
+        easing?: (t: number) => number;
+    }): void;
+    getScrollPosition(): number;
+    on<K extends keyof import("../types").VListEvents<T>>(event: K, handler: import("../types").EventHandler<import("../types").VListEvents<T>[K]>): import("../types").Unsubscribe;
+    off<K extends keyof import("../types").VListEvents<T>>(event: K, handler: import("../types").EventHandler<import("../types").VListEvents<T>[K]>): void;
+    destroy(): void;
+    [key: string]: unknown;
+}
+export interface CreateVListConfig<T extends VListItem = VListItem> {
+    container: HTMLElement | string;
+    item: {
+        height?: number | ((index: number) => number);
+        width?: number | ((index: number) => number);
+        estimatedHeight?: number;
+        estimatedWidth?: number;
+        template: ItemTemplate<T>;
+        gap?: number;
+        striped?: boolean | "data" | "even" | "odd";
+    };
+    items?: T[];
+    overscan?: number;
+    classPrefix?: string;
+    orientation?: "vertical" | "horizontal";
+    padding?: number | [number, number] | [number, number, number, number];
+    interactive?: boolean;
+    reverse?: boolean;
+    ariaLabel?: string;
+    scroll?: {
+        wheel?: boolean;
+        scrollbar?: "none";
+        gutter?: "auto" | "stable";
+        idleTimeout?: number;
+    };
+    /** Defer initial render to the next animation frame. */
+    defer?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.js

@@ -0,0 +1,7 @@
+/**
+ * vlist v2 — Core Type Definitions
+ *
+ * Zero-allocation pipeline types. All hot-path state lives in TypedArrays
+ * on the EngineState singleton — no intermediate object allocation.
+ */
+export {};

package/dist/{builder → core}/velocity.d.ts

@@ -1,5 +1,5 @@
 /**
- * vlist/builder — Velocity Tracking
+ * vlist v2 — Velocity Tracking
  * Lightweight 2-sample velocity tracker for scroll momentum detection.
  */
 export declare const MIN_RELIABLE_SAMPLES = 2;

package/dist/core/velocity.js

@@ -0,0 +1,33 @@
+/**
+ * vlist v2 — Velocity Tracking
+ * Lightweight 2-sample velocity tracker for scroll momentum detection.
+ */
+export const MIN_RELIABLE_SAMPLES = 2;
+/** Create a velocity tracker. */
+export const createVelocityTracker = (_initialPosition = 0) => ({
+    velocity: 0,
+    sampleCount: 0,
+});
+/** Update velocity from new scroll position. Mutates tracker in place. */
+export const updateVelocityTracker = (tracker, newPosition) => {
+    const now = performance.now();
+    const lastTime = tracker._lt ?? now;
+    const lastPos = tracker._lp ?? newPosition;
+    const dt = now - lastTime;
+    tracker._lp = newPosition;
+    tracker._lt = now;
+    // Zero time delta — record position but can't compute velocity
+    if (dt === 0) {
+        tracker.sampleCount = Math.min(tracker.sampleCount + 1, 5);
+        return tracker;
+    }
+    // Stale gap — reset
+    if (dt > 100) {
+        tracker.velocity = 0;
+        tracker.sampleCount = 1;
+        return tracker;
+    }
+    tracker.velocity = Math.abs(newPosition - lastPos) / dt;
+    tracker.sampleCount = Math.min(tracker.sampleCount + 1, 5);
+    return tracker;
+};

package/dist/events/emitter.js

@@ -0,0 +1,60 @@
+/**
+ * vlist - Event Emitter
+ * Lightweight, type-safe event system
+ */
+// =============================================================================
+// Event Emitter
+// =============================================================================
+/**
+ * Create a type-safe event emitter
+ * Functional approach - returns an object with methods
+ */
+export const createEmitter = () => {
+    const listeners = {};
+    /**
+     * Subscribe to an event
+     */
+    const on = (event, handler) => {
+        if (!listeners[event]) {
+            listeners[event] = new Set();
+        }
+        listeners[event].add(handler);
+        // Return unsubscribe function
+        return () => off(event, handler);
+    };
+    /**
+     * Unsubscribe from an event
+     */
+    const off = (event, handler) => {
+        listeners[event]?.delete(handler);
+    };
+    /**
+     * Emit an event to all subscribers
+     */
+    const emit = (event, payload) => {
+        listeners[event]?.forEach((handler) => {
+            try {
+                handler(payload);
+            }
+            catch (error) {
+                if (process.env.NODE_ENV !== "production") {
+                    console.error(`[vlist] Error in event handler for "${String(event)}":`, error);
+                }
+            }
+        });
+    };
+    /**
+     * Remove all listeners for an event (or all events if no event specified)
+     */
+    const clear = (event) => {
+        if (event) {
+            delete listeners[event];
+        }
+        else {
+            for (const key in listeners) {
+                delete listeners[key];
+            }
+        }
+    };
+    return { on, off, emit, clear };
+};

package/dist/events/index.js

@@ -0,0 +1,6 @@
+/**
+ * vlist - Events Domain
+ * Event emitter system
+ */
+// Event Emitter
+export { createEmitter } from "./emitter";

package/dist/index.d.ts

@@ -8,26 +8,35 @@
  *
  * @packageDocumentation
  */
-export { vlist } from "./builder";
-export { withScale } from "./features/scale";
-export type { ScaleConfig } from "./features/scale";
-export { withAsync } from "./features/async";
-export { withScrollbar } from "./features/scrollbar";
-export { withPage } from "./features/page";
-export type { WithPageOptions } from "./features/page";
-export { withGroups } from "./features/groups";
-export { withGrid } from "./features/grid";
-export { withMasonry } from "./features/masonry";
-export { withSelection } from "./features/selection";
-export { withSnapshots } from "./features/snapshots";
-export { withTable } from "./features/table";
-export { withSortable } from "./features/sortable";
-export type { SortableConfig } from "./features/sortable";
-export { withAutoSize } from "./features/autosize";
-export { withTransition } from "./features/transition";
-export type { TransitionConfig, TransitionTiming } from "./features/transition";
+export { createVList } from "./core/create";
+export { scale } from "./plugins/scale";
+export type { ScalePluginConfig } from "./plugins/scale";
+export { scrollbar } from "./plugins/scrollbar";
+export type { ScrollbarPluginConfig } from "./plugins/scrollbar";
+export { grid } from "./plugins/grid";
+export { a11y } from "./plugins/a11y";
+export { selection } from "./plugins/selection";
+export type { SelectionPluginConfig } from "./plugins/selection";
+export { page } from "./plugins/page";
+export type { PagePluginConfig } from "./plugins/page";
+export { snapshots } from "./plugins/snapshots";
+export type { SnapshotsPluginConfig } from "./plugins/snapshots";
+export { transition } from "./plugins/transition";
+export type { TransitionPluginConfig } from "./plugins/transition";
+export { autosize } from "./plugins/autosize";
+export type { AutosizePluginConfig } from "./plugins/autosize";
+export { masonry } from "./plugins/masonry";
+export type { MasonryPluginConfig } from "./plugins/masonry";
+export { data } from "./plugins/async";
+export type { DataPluginConfig } from "./plugins/async";
+export { groups } from "./plugins/groups";
+export type { GroupsPluginConfig } from "./plugins/groups";
+export { table } from "./plugins/table";
+export type { TablePluginConfig } from "./plugins/table";
+export { sortable } from "./plugins/sortable";
+export type { SortablePluginConfig } from "./plugins/sortable";
 export { createStats } from "./utils/stats";
 export type { Stats, StatsConfig, StatsState } from "./utils/stats";
 export type { VListItem, VListEvents, ItemConfig, ItemTemplate, ItemState, SelectionMode, SelectionConfig, SelectionState, ScrollbarConfig, ScrollbarPadding, ScrollbarOptions, ScrollConfig, ScrollToOptions, ScrollSnapshot, VListAdapter, AdapterParams, AdapterResponse, Range, ViewportState, EventHandler, Unsubscribe, GridConfig, MasonryConfig, GroupsConfig, GroupHeaderConfig, GridSizeContext, GridHeightContext, } from "./types";
-export type { VListBuilder, VList, BuilderConfig, VListConfig, VListFeature, BuilderContext, ReloadOptions, } from "./builder";
+export type { VList, VListPlugin, PluginContext, CreateVListConfig, CompiledHooks, ResolvedConfig, DOMStructure, ElementPool, } from "./core/types";
 //# sourceMappingURL=index.d.ts.map