@floor/vlist 0.5.1

package/dist/plugins/snapshots/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * vlist/snapshots - Scroll Save/Restore
+ * Plugin for SPA navigation and tab switching
+ *
+ * Usage: import { withSnapshots } from 'vlist/snapshots'
+ */
+export { withSnapshots } from "./plugin";
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/snapshots/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/snapshots/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC"}

package/dist/plugins/snapshots/plugin.d.ts

@@ -0,0 +1,44 @@
+/**
+ * vlist/snapshots - Builder Plugin
+ * Adds scroll save/restore for SPA navigation and tab switching.
+ *
+ * Priority: 50 (runs last — needs all other plugins initialized)
+ *
+ * What it wires:
+ * - getScrollSnapshot() — captures current scroll position (item index + sub-pixel offset)
+ * - restoreScroll() — restores scroll position from snapshot
+ *
+ * Snapshots capture the first visible item index and the pixel offset within
+ * that item — not raw scrollTop. This means:
+ * - Snapshots survive list recreation (navigate away and back)
+ * - Snapshots work correctly with compression (1M+ items)
+ * - Snapshots include selection state if selection is installed
+ *
+ * Added methods: getScrollSnapshot, restoreScroll
+ */
+import type { VListItem } from "../../types";
+import type { VListPlugin } from "../../builder/types";
+/**
+ * Create a snapshots plugin for the builder.
+ *
+ * Adds scroll save/restore for SPA navigation and tab switching.
+ *
+ * ```ts
+ * import { vlist } from 'vlist/builder'
+ * import { withSnapshots } from 'vlist/snapshots'
+ *
+ * const list = vlist({ ... })
+ *   .use(withSnapshots())
+ *   .build()
+ *
+ * // Save before navigating away
+ * const snapshot = list.getScrollSnapshot()
+ * sessionStorage.setItem('list-scroll', JSON.stringify(snapshot))
+ *
+ * // Restore when coming back
+ * const saved = JSON.parse(sessionStorage.getItem('list-scroll'))
+ * if (saved) list.restoreScroll(saved)
+ * ```
+ */
+export declare const withSnapshots: <T extends VListItem = VListItem>() => VListPlugin<T>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugins/snapshots/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/snapshots/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,aAAa,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,qBAAqB,CAAC;AAUvE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,SAAS,GAAG,SAAS,OAAK,WAAW,CAAC,CAAC,CA4G9E,CAAC"}

package/dist/plugins/window/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * vlist/window - Window Scroll Mode Plugin
+ *
+ * Entry point for the window scroll plugin.
+ */
+export { withWindow } from "./plugin";
+export type { VListPlugin } from "../../builder/types";
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/window/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/window/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/plugins/window/plugin.d.ts

@@ -0,0 +1,53 @@
+/**
+ * vlist/window - Window Scroll Mode Plugin
+ *
+ * Enables the list to scroll with the page instead of in its own container.
+ * Useful for infinite feeds, full-page lists, and chat UIs that integrate
+ * with page scroll.
+ *
+ * Priority: 5 (runs early, before other plugins that depend on scroll)
+ *
+ * What it does:
+ * - Uses window as scroll target instead of viewport element
+ * - Calculates scroll position relative to document
+ * - Uses window.innerWidth/innerHeight for container dimensions
+ * - Listens to window resize events instead of ResizeObserver
+ * - Adjusts DOM styles (overflow: visible, height: auto)
+ *
+ * Bundle impact: ~0.3 KB gzipped when used
+ */
+import type { VListItem } from "../../types";
+import type { VListPlugin } from "../../builder/types";
+/**
+ * Create a window scroll mode plugin.
+ *
+ * Use this when you want your list to scroll with the page instead of
+ * in a fixed-height container.
+ *
+ * @example
+ * ```ts
+ * import { vlist } from 'vlist/builder'
+ * import { withWindow } from 'vlist/window'
+ *
+ * const feed = vlist({
+ *   container: '#infinite-feed',
+ *   item: { height: 200, template: renderPost },
+ *   items: posts
+ * })
+ * .use(withWindow())
+ * .build()
+ * ```
+ *
+ * @example Horizontal window scrolling
+ * ```ts
+ * const timeline = vlist({
+ *   container: '#timeline',
+ *   item: { height: 100, template: renderEvent },
+ *   direction: 'horizontal'
+ * })
+ * .use(withWindow())
+ * .build()
+ * ```
+ */
+export declare const withWindow: <T extends VListItem = VListItem>() => VListPlugin<T>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugins/window/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/window/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,qBAAqB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,UAAU,GACrB,CAAC,SAAS,SAAS,GAAG,SAAS,OAC5B,WAAW,CAAC,CAAC,CA+HjB,CAAC"}

package/dist/react/index.js

@@ -0,0 +1 @@
+import{useRef as D,useEffect as K,useCallback as M}from"react";import{createVList as N}from"vlist";function Q(q){let A=D(null),j=D(null),B=D(q);B.current=q;let z=D(!1);K(()=>{let J=A.current;if(!J)return;let F=N({...B.current,container:J});return j.current=F,z.current=!0,()=>{z.current=!1,F.destroy(),j.current=null}},[]),K(()=>{if(!z.current||!j.current)return;if(q.items)j.current.setItems(q.items)},[q.items]);let G=M(()=>{return j.current},[]);return{containerRef:A,instanceRef:j,getInstance:G}}function S(q,A,j){let B=D(j);B.current=j,K(()=>{let z=q.current;if(!z)return;let G=(F)=>{B.current(F)};return z.on(A,G)},[q.current,A])}export{S as useVListEvent,Q as useVList};

package/dist/render/compression.d.ts

@@ -0,0 +1,116 @@
+/**
+ * vlist - Compression Module
+ * Pure functions for handling large lists that exceed browser height limits
+ *
+ * When a list's total height (totalItems × itemHeight) exceeds the browser's
+ * maximum element height (~16.7M pixels), we "compress" the virtual scroll space.
+ *
+ * Key concepts:
+ * - actualHeight: The true height if all items were rendered
+ * - virtualHeight: The capped height used for the scroll container (≤ MAX_VIRTUAL_HEIGHT)
+ * - compressionRatio: virtualHeight / actualHeight (1 = no compression, <1 = compressed)
+ *
+ * When compressed:
+ * - Scroll position maps to item index via ratio, not pixel math
+ * - Item positions are calculated relative to a "virtual index" at current scroll
+ * - Near-bottom interpolation ensures the last items are reachable
+ */
+import type { Range } from "../types";
+import { MAX_VIRTUAL_HEIGHT } from "../constants";
+import type { HeightCache } from "./heights";
+export { MAX_VIRTUAL_HEIGHT };
+/** Compression calculation result */
+export interface CompressionState {
+    /** Whether compression is active */
+    isCompressed: boolean;
+    /** The actual total height */
+    actualHeight: number;
+    /** The virtual height (capped at MAX_VIRTUAL_HEIGHT) */
+    virtualHeight: number;
+    /** Compression ratio (1 = no compression, <1 = compressed) */
+    ratio: number;
+}
+/**
+ * Calculate compression state for a list
+ * Pure function - no side effects
+ */
+export declare const getCompressionState: (_totalItems: number, heightCache: HeightCache) => CompressionState;
+/**
+ * Calculate visible range with compression support
+ * Pure function - no side effects
+ *
+ * @param scrollTop - Current scroll position
+ * @param containerHeight - Viewport container height
+ * @param heightCache - Height cache for item heights/offsets
+ * @param totalItems - Total number of items
+ * @param compression - Compression state
+ * @param out - Output range to mutate (avoids allocation on hot path)
+ */
+export declare const calculateCompressedVisibleRange: (scrollTop: number, containerHeight: number, heightCache: HeightCache, totalItems: number, compression: CompressionState, out: Range) => Range;
+/**
+ * Calculate render range with compression support (adds overscan)
+ * Pure function - no side effects
+ *
+ * @param out - Output range to mutate (avoids allocation on hot path)
+ */
+export declare const calculateCompressedRenderRange: (visibleRange: Range, overscan: number, totalItems: number, out: Range) => Range;
+/**
+ * Calculate item position (translateY) with compression support
+ * Pure function - no side effects
+ *
+ * In compressed mode (manual wheel scrolling, overflow: hidden), items are
+ * positioned RELATIVE TO THE VIEWPORT. The scroll container doesn't actually
+ * scroll - we intercept wheel events and manually position items.
+ *
+ * Key insight:
+ * - Calculate a "virtual scroll index" from the scroll ratio
+ * - Items are positioned relative to this virtual index using actual heights
+ * - Each item keeps its full height for proper rendering
+ *
+ * @param index - Item index
+ * @param scrollTop - Current (virtual) scroll position
+ * @param heightCache - Height cache for item heights/offsets
+ * @param totalItems - Total number of items
+ * @param containerHeight - Viewport container height
+ * @param compression - Compression state
+ * @param _rangeStart - (unused, kept for API compatibility)
+ */
+export declare const calculateCompressedItemPosition: (index: number, scrollTop: number, heightCache: HeightCache, totalItems: number, containerHeight: number, compression: CompressionState, _rangeStart?: number) => number;
+/**
+ * Calculate scroll position to bring an index into view (with compression)
+ * Pure function - no side effects
+ *
+ * @param index - Target item index
+ * @param heightCache - Height cache for item heights/offsets
+ * @param containerHeight - Viewport container height
+ * @param totalItems - Total number of items
+ * @param compression - Compression state
+ * @param align - Alignment within viewport
+ */
+export declare const calculateCompressedScrollToIndex: (index: number, heightCache: HeightCache, containerHeight: number, totalItems: number, compression: CompressionState, align?: "start" | "center" | "end") => number;
+/**
+ * Calculate the approximate item index at a given scroll position
+ * Useful for debugging and scroll position restoration
+ * Pure function - no side effects
+ */
+export declare const calculateIndexFromScrollPosition: (scrollTop: number, heightCache: HeightCache, totalItems: number, compression: CompressionState) => number;
+/**
+ * Check if compression is needed for a list configuration
+ * Pure function - no side effects
+ *
+ * Note: This overload accepts a HeightCache for variable heights.
+ * For simple fixed-height checks, use needsCompressionFixed().
+ */
+export declare const needsCompression: (totalItems: number, heightOrCache: number | HeightCache) => boolean;
+/**
+ * Calculate maximum items supported without compression
+ * Only meaningful for fixed-height items
+ * Pure function - no side effects
+ */
+export declare const getMaxItemsWithoutCompression: (itemHeight: number) => number;
+/**
+ * Get human-readable compression info for debugging
+ * Pure function - no side effects
+ */
+export declare const getCompressionInfo: (totalItems: number, heightCache: HeightCache) => string;
+//# sourceMappingURL=compression.d.ts.map

package/dist/render/compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../../src/render/compression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAQ7C,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAM9B,qCAAqC;AACrC,MAAM,WAAW,gBAAgB;IAC/B,oCAAoC;IACpC,YAAY,EAAE,OAAO,CAAC;IAEtB,8BAA8B;IAC9B,YAAY,EAAE,MAAM,CAAC;IAErB,wDAAwD;IACxD,aAAa,EAAE,MAAM,CAAC;IAEtB,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC9B,aAAa,MAAM,EACnB,aAAa,WAAW,KACvB,gBAYF,CAAC;AAMF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,+BAA+B,GAC1C,WAAW,MAAM,EACjB,iBAAiB,MAAM,EACvB,aAAa,WAAW,EACxB,YAAY,MAAM,EAClB,aAAa,gBAAgB,EAC7B,KAAK,KAAK,KACT,KAmEF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,GACzC,cAAc,KAAK,EACnB,UAAU,MAAM,EAChB,YAAY,MAAM,EAClB,KAAK,KAAK,KACT,KAUF,CAAC;AAMF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,+BAA+B,GAC1C,OAAO,MAAM,EACb,WAAW,MAAM,EACjB,aAAa,WAAW,EACxB,YAAY,MAAM,EAClB,iBAAiB,MAAM,EACvB,aAAa,gBAAgB,EAC7B,cAAc,MAAM,KACnB,MAyDF,CAAC;AAMF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gCAAgC,GAC3C,OAAO,MAAM,EACb,aAAa,WAAW,EACxB,iBAAiB,MAAM,EACvB,YAAY,MAAM,EAClB,aAAa,gBAAgB,EAC7B,QAAO,OAAO,GAAG,QAAQ,GAAG,KAAe,KAC1C,MAmCF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,GAC3C,WAAW,MAAM,EACjB,aAAa,WAAW,EACxB,YAAY,MAAM,EAClB,aAAa,gBAAgB,KAC5B,MASF,CAAC;AAMF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAC3B,YAAY,MAAM,EAClB,eAAe,MAAM,GAAG,WAAW,KAClC,OAKF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,GAAI,YAAY,MAAM,KAAG,MAGlE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC7B,YAAY,MAAM,EAClB,aAAa,WAAW,KACvB,MASF,CAAC"}

package/dist/render/heights.d.ts

@@ -0,0 +1,63 @@
+/**
+ * vlist - Height Cache
+ * Efficient height management for fixed and variable item heights
+ *
+ * Provides two implementations:
+ * - Fixed: O(1) operations using multiplication (zero overhead, matches existing behavior)
+ * - Variable: O(1) offset lookup via prefix sums, O(log n) binary search for index-at-offset
+ *
+ * The HeightCache abstraction allows all virtual scrolling and compression code
+ * to work identically with both fixed and variable heights.
+ */
+/** Height cache for efficient offset/index lookups */
+export interface HeightCache {
+    /** Get offset (Y position) for an item index — O(1) */
+    getOffset(index: number): number;
+    /** Get height of a specific item */
+    getHeight(index: number): number;
+    /** Find item index at a scroll offset — O(1) fixed, O(log n) variable */
+    indexAtOffset(offset: number): number;
+    /** Total content height */
+    getTotalHeight(): number;
+    /** Current total item count */
+    getTotal(): number;
+    /** Rebuild cache (call when items change) */
+    rebuild(totalItems: number): void;
+    /** Whether heights are variable (false = fixed fast path) */
+    isVariable(): boolean;
+}
+/**
+ * Create a height cache — returns fixed or variable implementation
+ *
+ * When height is a number, returns a zero-overhead fixed implementation.
+ * When height is a function, builds a prefix-sum array for efficient lookups.
+ */
+export declare const createHeightCache: (height: number | ((index: number) => number), initialTotal: number) => HeightCache;
+/**
+ * Count how many items fit in a given container height starting from startIndex
+ * Used for compressed mode visible range calculations
+ *
+ * For fixed heights: O(1) via division
+ * For variable heights: O(k) where k = visible item count (typically 10-50)
+ */
+export declare const countVisibleItems: (heightCache: HeightCache, startIndex: number, containerHeight: number, totalItems: number) => number;
+/**
+ * Count how many items fit starting from the bottom of the list
+ * Used for near-bottom interpolation in compressed mode
+ *
+ * For fixed heights: O(1) via division
+ * For variable heights: O(k) where k = items fitting (typically 10-50)
+ */
+export declare const countItemsFittingFromBottom: (heightCache: HeightCache, containerHeight: number, totalItems: number) => number;
+/**
+ * Calculate the pixel offset for a fractional virtual scroll index
+ *
+ * In compressed mode, the scroll position maps to a fractional item index
+ * (e.g., 5.3 means 30% into item 5). This function calculates the actual
+ * pixel offset for such a fractional position using variable heights.
+ *
+ * For fixed heights this reduces to: virtualIndex * itemHeight
+ * For variable heights: offset(floor) + frac * height(floor)
+ */
+export declare const getOffsetForVirtualIndex: (heightCache: HeightCache, virtualIndex: number, totalItems: number) => number;
+//# sourceMappingURL=heights.d.ts.map

package/dist/render/heights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heights.d.ts","sourceRoot":"","sources":["../../src/render/heights.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,sDAAsD;AACtD,MAAM,WAAW,WAAW;IAC1B,uDAAuD;IACvD,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAEjC,oCAAoC;IACpC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAEjC,yEAAyE;IACzE,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAEtC,2BAA2B;IAC3B,cAAc,IAAI,MAAM,CAAC;IAEzB,+BAA+B;IAC/B,QAAQ,IAAI,MAAM,CAAC;IAEnB,6CAA6C;IAC7C,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAElC,6DAA6D;IAC7D,UAAU,IAAI,OAAO,CAAC;CACvB;AAiID;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,EAC5C,cAAc,MAAM,KACnB,WAKF,CAAC;AAMF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,aAAa,WAAW,EACxB,YAAY,MAAM,EAClB,iBAAiB,MAAM,EACvB,YAAY,MAAM,KACjB,MAkBF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GACtC,aAAa,WAAW,EACxB,iBAAiB,MAAM,EACvB,YAAY,MAAM,KACjB,MAkBF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GACnC,aAAa,WAAW,EACxB,cAAc,MAAM,EACpB,YAAY,MAAM,KACjB,MAUF,CAAC"}

package/dist/render/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * vlist - Render Domain
+ * Rendering, virtualization, and compression
+ */
+export { createHeightCache, countVisibleItems, countItemsFittingFromBottom, getOffsetForVirtualIndex, type HeightCache, } from "./heights";
+export { createRenderer, createDOMStructure, updateContentHeight, updateContentWidth, resolveContainer, getContainerDimensions, type Renderer, type DOMStructure, type CompressionContext, type CompressedPositionFn, type CompressionStateFn, } from "./renderer";
+export { createViewportState, updateViewportState, updateViewportSize, updateViewportItems, calculateRenderRange, calculateTotalHeight, calculateActualHeight, calculateItemOffset, calculateScrollToIndex, clampScrollPosition, getScrollDirection, rangesEqual, isInRange, getRangeCount, diffRanges, getSimpleCompressionState, simpleVisibleRange, simpleScrollToIndex, NO_COMPRESSION, type CompressionState, type VisibleRangeFn, type ScrollToIndexFn, } from "./virtual";
+export { MAX_VIRTUAL_HEIGHT, getCompressionState, getCompressionState as getCompression, needsCompression, getMaxItemsWithoutCompression, getCompressionInfo, calculateCompressedVisibleRange, calculateCompressedRenderRange, calculateCompressedItemPosition, calculateCompressedScrollToIndex, calculateIndexFromScrollPosition, } from "./compression";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/render/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,2BAA2B,EAC3B,wBAAwB,EACxB,KAAK,WAAW,GACjB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,GACxB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EAClB,WAAW,EACX,SAAS,EACT,aAAa,EACb,UAAU,EACV,yBAAyB,EACzB,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,eAAe,GACrB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,IAAI,cAAc,EACrC,gBAAgB,EAChB,6BAA6B,EAC7B,kBAAkB,EAClB,+BAA+B,EAC/B,8BAA8B,EAC9B,+BAA+B,EAC/B,gCAAgC,EAChC,gCAAgC,GACjC,MAAM,eAAe,CAAC"}

package/dist/render/renderer.d.ts

@@ -0,0 +1,103 @@
+/**
+ * vlist - DOM Rendering
+ * Efficient DOM rendering with element pooling
+ * Supports compression for large lists (1M+ items)
+ */
+import type { VListItem, ItemTemplate, Range } from "../types";
+import type { CompressionState } from "./virtual";
+import type { HeightCache } from "./heights";
+/**
+ * Optional compression position calculator.
+ * Injected by the monolithic factory or the withCompression plugin.
+ * When not provided, the renderer uses simple heightCache offsets.
+ */
+export type CompressedPositionFn = (index: number, scrollTop: number, heightCache: HeightCache, totalItems: number, containerHeight: number, compression: CompressionState, rangeStart?: number) => number;
+/**
+ * Optional compression state getter.
+ * Injected by the monolithic factory or the withCompression plugin.
+ * When not provided, the renderer assumes no compression.
+ */
+export type CompressionStateFn = (totalItems: number, heightCache: HeightCache) => CompressionState;
+/** Element pool for recycling DOM elements */
+export interface ElementPool {
+    /** Get an element from the pool (or create new) */
+    acquire: () => HTMLElement;
+    /** Return an element to the pool */
+    release: (element: HTMLElement) => void;
+    /** Clear the pool */
+    clear: () => void;
+    /** Get pool statistics */
+    stats: () => {
+        poolSize: number;
+        created: number;
+        reused: number;
+    };
+}
+/** Compression context for positioning */
+export interface CompressionContext {
+    scrollTop: number;
+    totalItems: number;
+    containerHeight: number;
+    rangeStart: number;
+}
+/** DOM structure created by createDOMStructure */
+export interface DOMStructure {
+    root: HTMLElement;
+    viewport: HTMLElement;
+    content: HTMLElement;
+    items: HTMLElement;
+}
+/** Renderer instance */
+export interface Renderer<T extends VListItem = VListItem> {
+    /** Render items for a range */
+    render: (items: T[], range: Range, selectedIds: Set<string | number>, focusedIndex: number, compressionCtx?: CompressionContext) => void;
+    /** Update item positions (for compressed scrolling) */
+    updatePositions: (compressionCtx: CompressionContext) => void;
+    /** Update a single item */
+    updateItem: (index: number, item: T, isSelected: boolean, isFocused: boolean) => void;
+    /** Update only CSS classes on a rendered item (no template re-evaluation) */
+    updateItemClasses: (index: number, isSelected: boolean, isFocused: boolean) => void;
+    /** Get rendered item element by index */
+    getElement: (index: number) => HTMLElement | undefined;
+    /** Clear all rendered items */
+    clear: () => void;
+    /** Destroy renderer and cleanup */
+    destroy: () => void;
+}
+/**
+ * Create an element pool for recycling DOM elements
+ * Reduces garbage collection and improves performance
+ */
+export declare const createElementPool: (tagName?: string, maxSize?: number) => ElementPool;
+/**
+ * Create a renderer for managing DOM elements
+ * Supports compression for large lists
+ */
+export declare const createRenderer: <T extends VListItem = VListItem>(itemsContainer: HTMLElement, template: ItemTemplate<T>, heightCache: HeightCache, classPrefix: string, totalItemsGetter?: () => number, ariaIdPrefix?: string, horizontal?: boolean, crossAxisSize?: number, compressionFns?: {
+    getState: CompressionStateFn;
+    getPosition: CompressedPositionFn;
+}) => Renderer<T>;
+/**
+ * Create the vlist DOM structure
+ */
+export declare const createDOMStructure: (container: HTMLElement, classPrefix: string, ariaLabel?: string, horizontal?: boolean) => DOMStructure;
+/**
+ * Update content height for virtual scrolling
+ */
+export declare const updateContentHeight: (content: HTMLElement, totalHeight: number) => void;
+/**
+ * Update content width for horizontal virtual scrolling
+ */
+export declare const updateContentWidth: (content: HTMLElement, totalWidth: number) => void;
+/**
+ * Get container dimensions
+ */
+export declare const getContainerDimensions: (viewport: HTMLElement) => {
+    width: number;
+    height: number;
+};
+/**
+ * Resolve container from selector or element
+ */
+export declare const resolveContainer: (container: HTMLElement | string) => HTMLElement;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/render/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/render/renderer.ts"],"names":[],"mappings":"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"}

package/dist/render/virtual.d.ts

@@ -0,0 +1,139 @@
+/**
+ * vlist - Virtual Scrolling Core
+ * Pure functions for virtual scroll calculations
+ *
+ * Compression support is NOT imported here — it's injected via
+ * CompressionState parameters. When compression is inactive
+ * (the common case), all calculations use simple height-cache math
+ * with zero dependency on the compression module.
+ *
+ * This keeps the builder core lightweight. The withCompression plugin
+ * and the monolithic createVList entry point import compression
+ * separately and pass the state in.
+ */
+import type { Range, ViewportState } from "../types";
+import type { HeightCache } from "./heights";
+/** Compression calculation result */
+export interface CompressionState {
+    /** Whether compression is active */
+    isCompressed: boolean;
+    /** The actual total height */
+    actualHeight: number;
+    /** The virtual height (capped at MAX_VIRTUAL_HEIGHT) */
+    virtualHeight: number;
+    /** Compression ratio (1 = no compression, <1 = compressed) */
+    ratio: number;
+}
+/**
+ * A "no compression" state for lists that don't need it.
+ * Used by the builder core when withCompression is not installed.
+ */
+export declare const NO_COMPRESSION: CompressionState;
+/**
+ * Create a trivial compression state from a height cache.
+ * No compression logic — just reads the total height.
+ * For use when the full compression module is not loaded.
+ */
+export declare const getSimpleCompressionState: (_totalItems: number, heightCache: HeightCache) => CompressionState;
+/**
+ * Signature for the function that calculates the visible item range.
+ * The compression module provides a version that handles compressed scroll;
+ * virtual.ts provides a simple fallback for non-compressed lists.
+ */
+export type VisibleRangeFn = (scrollTop: number, containerHeight: number, heightCache: HeightCache, totalItems: number, compression: CompressionState, out: Range) => Range;
+/**
+ * Signature for the scroll-to-index calculator.
+ */
+export type ScrollToIndexFn = (index: number, heightCache: HeightCache, containerHeight: number, totalItems: number, compression: CompressionState, align: "start" | "center" | "end") => number;
+/**
+ * Calculate visible range using height cache lookups.
+ * Fast path for lists that don't need compression (< ~350 000 items at 48px).
+ * Mutates `out` to avoid allocation on the scroll hot path.
+ */
+export declare const simpleVisibleRange: VisibleRangeFn;
+/**
+ * Calculate render range (adds overscan around visible range).
+ * This function is compression-agnostic — works for both paths.
+ * Mutates `out` to avoid allocation on the scroll hot path.
+ */
+export declare const calculateRenderRange: (visibleRange: Range, overscan: number, totalItems: number, out: Range) => Range;
+/**
+ * Simple scroll-to-index calculation (non-compressed).
+ * Uses height cache offsets directly.
+ */
+export declare const simpleScrollToIndex: ScrollToIndexFn;
+/**
+ * Calculate total content height.
+ * Uses compression's virtualHeight when compressed, raw height otherwise.
+ */
+export declare const calculateTotalHeight: (_totalItems: number, heightCache: HeightCache, compression?: CompressionState | null) => number;
+/**
+ * Calculate actual total height (without compression cap)
+ */
+export declare const calculateActualHeight: (_totalItems: number, heightCache: HeightCache) => number;
+/**
+ * Calculate the offset (translateY) for an item
+ * For non-compressed lists only
+ */
+export declare const calculateItemOffset: (index: number, heightCache: HeightCache) => number;
+/**
+ * Clamp scroll position to valid range
+ */
+export declare const clampScrollPosition: (scrollTop: number, totalHeight: number, containerHeight: number) => number;
+/**
+ * Determine scroll direction
+ */
+export declare const getScrollDirection: (currentScrollTop: number, previousScrollTop: number) => "up" | "down";
+/**
+ * Create initial viewport state.
+ *
+ * Accepts an optional `visibleRangeFn` so that compression-aware callers
+ * can inject the compressed version. Defaults to `simpleVisibleRange`.
+ */
+export declare const createViewportState: (containerHeight: number, heightCache: HeightCache, totalItems: number, overscan: number, compression: CompressionState, visibleRangeFn?: VisibleRangeFn) => ViewportState;
+/**
+ * Update viewport state after scroll.
+ * Mutates state in place for performance on the scroll hot path.
+ */
+export declare const updateViewportState: (state: ViewportState, scrollTop: number, heightCache: HeightCache, totalItems: number, overscan: number, compression: CompressionState, visibleRangeFn?: VisibleRangeFn) => ViewportState;
+/**
+ * Update viewport state when container resizes.
+ * Mutates state in place for performance.
+ */
+export declare const updateViewportSize: (state: ViewportState, containerHeight: number, heightCache: HeightCache, totalItems: number, overscan: number, compression: CompressionState, visibleRangeFn?: VisibleRangeFn) => ViewportState;
+/**
+ * Update viewport state when total items changes.
+ * Mutates state in place for performance.
+ */
+export declare const updateViewportItems: (state: ViewportState, heightCache: HeightCache, totalItems: number, overscan: number, compression: CompressionState, visibleRangeFn?: VisibleRangeFn) => ViewportState;
+/**
+ * Calculate scroll position to bring an index into view.
+ *
+ * Accepts an optional `scrollToIndexFn` so that compression-aware callers
+ * can inject the compressed version. Defaults to `simpleScrollToIndex`.
+ */
+export declare const calculateScrollToIndex: (index: number, heightCache: HeightCache, containerHeight: number, totalItems: number, align: "start" | "center" | "end" | undefined, compression: CompressionState, scrollToIndexFn?: ScrollToIndexFn) => number;
+/**
+ * Check if two ranges are equal
+ */
+export declare const rangesEqual: (a: Range, b: Range) => boolean;
+/**
+ * Check if an index is within a range
+ */
+export declare const isInRange: (index: number, range: Range) => boolean;
+/**
+ * Get the count of items in a range
+ */
+export declare const getRangeCount: (range: Range) => number;
+/**
+ * Create an array of indices from a range
+ */
+export declare const rangeToIndices: (range: Range) => number[];
+/**
+ * Calculate which indices need to be added/removed when range changes
+ */
+export declare const diffRanges: (oldRange: Range, newRange: Range) => {
+    add: number[];
+    remove: number[];
+};
+//# sourceMappingURL=virtual.d.ts.map

package/dist/render/virtual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual.d.ts","sourceRoot":"","sources":["../../src/render/virtual.ts"],"names":[],"mappings":"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"}

package/dist/scroll/index.js

@@ -0,0 +1 @@
+var Gj=(j,J,G={},_="vlist",F=!1)=>{let{autoHide:E=!0,autoHideDelay:D=1000,minThumbSize:H=30,showOnHover:V=!0,hoverZoneWidth:X=16,showOnViewportEnter:Z=!0}=G,Q=0,U=0,W=0,N=0,O=!1,q=!1,y=0,f=0,h=0,I=null,p=!1,R=null,M=null,S=F?"width":"height",x=F?"translateX":"translateY",b=F?(B)=>B.clientX:(B)=>B.clientY,t=F?"left":"top",L=document.createElement("div"),C=document.createElement("div"),A=V?document.createElement("div"):null,i=()=>{if(L.className=`${_}-scrollbar`,C.className=`${_}-scrollbar-thumb`,F)L.classList.add(`${_}-scrollbar--horizontal`);if(L.appendChild(C),j.appendChild(L),A){if(A.className=`${_}-scrollbar-hover`,F)A.classList.add(`${_}-scrollbar-hover--horizontal`),A.style.height=`${X}px`;else A.style.width=`${X}px`;j.appendChild(A)}},T=()=>{if(I)clearTimeout(I),I=null},P=()=>{if(!E)return;T(),I=setTimeout(d,D)},k=()=>{if(Q<=U)return;if(T(),!p)L.classList.add(`${_}-scrollbar--visible`),p=!0;if(E&&!O&&!q)P()},d=()=>{if(O||q)return;L.classList.remove(`${_}-scrollbar--visible`),p=!1},r=(B,g)=>{Q=B,U=g;let m=Q>U;if(L.style.display=m?"":"none",!m){d();return}let z=U/Q;W=Math.max(H,z*U),C.style[S]=`${W}px`,N=U-W,s(h)},s=(B)=>{if(h=B,Q<=U||N<=0)return;let g=Q-U,z=Math.min(1,Math.max(0,B/g))*N;C.style.transform=`${x}(${z}px)`},c=(B)=>{if(B.target===C)return;let g=L.getBoundingClientRect(),o=b(B)-g[t]-W/2,Kj=Math.max(0,Math.min(o,N))/N,jj=Q-U,Xj=Kj*jj;J(Xj),k()},n=(B)=>{B.preventDefault(),B.stopPropagation(),O=!0,y=b(B),f=h,T(),L.classList.add(`${_}-scrollbar--dragging`),document.addEventListener("mousemove",w),document.addEventListener("mouseup",v)},w=(B)=>{if(!O)return;let g=b(B)-y,m=N>0?g/N:0,z=Q-U,o=m*z,e=Math.max(0,Math.min(f+o,z)),jj=e/z*N;if(C.style.transform=`${x}(${jj}px)`,M=e,R===null)R=requestAnimationFrame(()=>{if(M!==null)J(M);R=null})},v=()=>{if(O=!1,R!==null)cancelAnimationFrame(R),R=null;if(M!==null)J(M),M=null;if(L.classList.remove(`${_}-scrollbar--dragging`),E&&!q)P();document.removeEventListener("mousemove",w),document.removeEventListener("mouseup",v)},a=()=>{if(Z)k()},K=()=>{if(!O){if(q=!1,E)P()}},Y=()=>{q=!0,T(),k()},$=()=>{if(q=!1,!O&&E)P()},u=()=>{if(T(),R!==null)cancelAnimationFrame(R),R=null;if(L.removeEventListener("click",c),L.removeEventListener("mouseenter",Y),L.removeEventListener("mouseleave",$),C.removeEventListener("mousedown",n),j.removeEventListener("mouseenter",a),j.removeEventListener("mouseleave",K),document.removeEventListener("mousemove",w),document.removeEventListener("mouseup",v),A){if(A.removeEventListener("mouseenter",Y),A.removeEventListener("mouseleave",$),A.parentNode)A.parentNode.removeChild(A)}if(L.parentNode)L.parentNode.removeChild(L)};if(i(),L.addEventListener("click",c),L.addEventListener("mouseenter",Y),L.addEventListener("mouseleave",$),C.addEventListener("mousedown",n),j.addEventListener("mouseenter",a),j.addEventListener("mouseleave",K),A)A.addEventListener("mouseenter",Y),A.addEventListener("mouseleave",$);return{show:k,hide:d,updateBounds:r,updatePosition:s,isVisible:()=>p,destroy:u}};var Yj=(j)=>{let J=null;return{name:"withScrollbar",priority:30,setup(G){let{dom:_,config:F}=G,{classPrefix:E,horizontal:D}=F;if(J=Gj(_.viewport,(X)=>G.scrollController.scrollTo(X),j??{},E,D),!_.viewport.classList.contains(`${E}-viewport--custom-scrollbar`))_.viewport.classList.add(`${E}-viewport--custom-scrollbar`);let H=G.getCachedCompression();J.updateBounds(H.virtualHeight,G.state.viewportState.containerHeight);let V=J;G.afterScroll.push((X,Z)=>{V.updatePosition(X),V.show()}),G.resizeHandlers.push((X,Z)=>{if(V){let Q=G.getCachedCompression();V.updateBounds(Q.virtualHeight,G.state.viewportState.containerHeight)}}),G.contentSizeHandlers.push(()=>{if(V){let X=G.getCachedCompression();V.updateBounds(X.virtualHeight,G.state.viewportState.containerHeight)}}),G.destroyHandlers.push(()=>{if(V)V.destroy()})},destroy(){if(J)J.destroy(),J=null}}};var Qj=(j=0)=>{let J=[,,,,,,,,];for(let G=0;G<8;G++)J[G]={position:0,time:0};return{velocity:0,lastPosition:j,lastTime:performance.now(),samples:J,sampleIndex:0,sampleCount:0}},l=(j,J)=>{let G=performance.now(),_=G-j.lastTime;if(_===0)return j;if(_>100){j.sampleCount=0,j.sampleIndex=0,j.velocity=0;let E=j.samples[0];return E.position=J,E.time=G,j.sampleIndex=1,j.sampleCount=1,j.lastPosition=J,j.lastTime=G,j}let F=j.samples[j.sampleIndex];if(F.position=J,F.time=G,j.sampleIndex=(j.sampleIndex+1)%8,j.sampleCount=Math.min(j.sampleCount+1,8),j.sampleCount>=2){let E=(j.sampleIndex-j.sampleCount+8)%8,D=j.samples[E],H=J-D.position,V=G-D.time;j.velocity=V>0?H/V:0}return j.lastPosition=J,j.lastTime=G,j},_j=(j)=>j.sampleCount>=3,$j=(j,J={})=>{let{wheel:G=!0,sensitivity:_=1,smoothing:F=!1,idleTimeout:E=150,onScroll:D,onIdle:H,scrollElement:V,horizontal:X=!1}=J,Z=!!V,Q=0,U=0,W=Z?X?window.innerWidth:window.innerHeight:X?j.clientWidth:j.clientHeight,N=J.compressed??!1,O=J.compression,q=Qj(),y=!1,f=null,I=Jj(()=>{let K=X?j.scrollLeft:j.scrollTop,Y=K>=Q?"down":"up";if(q=l(q,K),Q=K,D)D({scrollTop:Q,direction:Y,velocity:q.velocity});b()}),R=Jj(()=>{let K=j.getBoundingClientRect(),Y=X?Math.max(0,-K.left):Math.max(0,-K.top),$=Y>=Q?"down":"up";if(q=l(q,Y),Q=Y,!y)y=!0;if(D)D({scrollTop:Q,direction:$,velocity:q.velocity});b()}),M=(K)=>{K.preventDefault()},S=(K)=>{if(K.deltaX)return;K.preventDefault(),j.scrollLeft+=K.deltaY},x=(K)=>{if(!N)return;K.preventDefault();let Y=(X?K.deltaX||K.deltaY:K.deltaY)*_,$=Q+Y;if(F)$=Q+Y*0.3;if($=Math.max(0,Math.min($,U)),$!==Q){let B=$>=Q?"down":"up";if(q=l(q,$),Q=$,!y)y=!0;if(D)D({scrollTop:Q,direction:B,velocity:q.velocity});b()}},b=()=>{if(f)clearTimeout(f);f=setTimeout(()=>{if(y=!1,q=Qj(Q),H)H()},E)},t=(K)=>{if(N)return;if(N=!0,O=K,U=K.virtualHeight-W,Z)return;if(I.cancel(),j.removeEventListener("scroll",I),!G)j.removeEventListener("wheel",M);else if(X)j.removeEventListener("wheel",S);if(X)j.style.overflowX="hidden";else j.style.overflow="hidden";if(G)j.addEventListener("wheel",x,{passive:!1});let Y=X?j.scrollLeft:j.scrollTop;if(Y>0){let $=X?O?.actualHeight??j.scrollWidth:O?.actualHeight??j.scrollHeight;Q=Y/$*U}if(X)j.scrollLeft=0;else j.scrollTop=0},L=()=>{if(!N)return;if(N=!1,Z){O=void 0;return}if(j.removeEventListener("wheel",x),X)j.style.overflowX="auto";else j.style.overflow="auto";if(j.addEventListener("scroll",I,{passive:!0}),!G)j.addEventListener("wheel",M,{passive:!1});else if(X)j.addEventListener("wheel",S,{passive:!1});if(O&&Q>0){let Y=Q/U*(O.actualHeight-W);if(X)j.scrollLeft=Y;else j.scrollTop=Y}O=void 0},C=()=>{if(Z||N)return Q;return X?j.scrollLeft:j.scrollTop},A=(K,Y=!1)=>{let $=Math.max(0,Math.min(K,U||1/0));if(Z){let u=j.getBoundingClientRect();if(X){let B=u.left+window.scrollX;window.scrollTo({left:B+$,behavior:Y?"smooth":"auto"})}else{let B=u.top+window.scrollY;window.scrollTo({top:B+$,behavior:Y?"smooth":"auto"})}}else if(N){if($===Q)return;let B=$>=Q?"down":"up";if(q=l(q,$),Q=$,!y)y=!0;if(D)D({scrollTop:Q,direction:B,velocity:q.velocity});b()}else if(X)j.scrollTo({left:$,behavior:Y?"smooth":"auto"});else j.scrollTo({top:$,behavior:Y?"smooth":"auto"})},i=(K)=>{A(C()+K)},T=()=>{return C()<=0},P=(K=0)=>{let Y=C(),$=Z||N?U:X?j.scrollWidth-j.clientWidth:j.scrollHeight-j.clientHeight;return Y>=$-K},k=()=>{let K=C(),Y=Z||N?U:X?j.scrollWidth-j.clientWidth:j.scrollHeight-j.clientHeight;if(Y<=0)return 0;return Math.min(1,Math.max(0,K/Y))},d=(K)=>{if(K.compression)O=K.compression,U=O.virtualHeight-W},r=()=>N,s=()=>Math.abs(q.velocity),c=()=>_j(q),n=()=>y,w=()=>Z,v=(K)=>{if(W=K,O)U=O.virtualHeight-W},a=()=>{if(f)clearTimeout(f);if(Z)R.cancel(),window.removeEventListener("scroll",R);else I.cancel(),j.removeEventListener("scroll",I),j.removeEventListener("wheel",x),j.removeEventListener("wheel",M),j.removeEventListener("wheel",S)};if(Z){if(N&&O)U=O.virtualHeight-W;window.addEventListener("scroll",R,{passive:!0})}else if(N&&O){if(U=O.virtualHeight-W,X)j.style.overflowX="hidden";else j.style.overflow="hidden";if(G)j.addEventListener("wheel",x,{passive:!1})}else{if(X)j.style.overflowX="auto",j.style.overflowY="hidden";else j.style.overflow="auto";if(j.addEventListener("scroll",I,{passive:!0}),!G)j.addEventListener("wheel",M,{passive:!1});else if(X)j.addEventListener("wheel",S,{passive:!1})}return{getScrollTop:C,scrollTo:A,scrollBy:i,isAtTop:T,isAtBottom:P,getScrollPercentage:k,getVelocity:s,isTracking:c,isScrolling:n,updateConfig:d,enableCompression:t,disableCompression:L,isCompressed:r,isWindowMode:w,updateContainerHeight:v,destroy:a}},Jj=(j)=>{let J=null,G=null,_=(...F)=>{if(G=F,J===null)J=requestAnimationFrame(()=>{if(J=null,G)j(...G)})};return _.cancel=()=>{if(J!==null)cancelAnimationFrame(J),J=null},_},Bj=(j,J,G,_=0)=>{return j+G>=J-_},Oj=(j,J=0)=>{return j<=J},Uj=(j,J,G)=>{let _=J-G;if(_<=0)return 0;return Math.min(1,Math.max(0,j/_))},qj=(j,J,G,_)=>{return j<=_&&J>=G};export{Yj as withScrollbar,Jj as rafThrottle,qj as isRangeVisible,Oj as isAtTop,Bj as isAtBottom,Uj as getScrollPercentage,Gj as createScrollbar,$j as createScrollController};

package/dist/selection/index.js

@@ -0,0 +1 @@
+var H=(D)=>({selected:new Set(D??[]),focusedIndex:-1}),E=(D,q,G)=>{if(G==="none")return D;let j=new Set(D.selected);if(G==="single"){if(j.clear(),q.length>0)j.add(q[0])}else for(let J of q)j.add(J);return{...D,selected:j}},F=(D,q)=>{let G=new Set(D.selected);for(let j of q)G.delete(j);return{...D,selected:G}},V=(D,q,G)=>{if(G==="none")return D;if(D.selected.has(q))return F(D,[q]);else return E(D,[q],G)},C=(D,q,G)=>{if(G!=="multiple")return D;return{...D,selected:new Set(q.map((j)=>j.id))}},f=(D)=>({...D,selected:new Set}),w=(D,q)=>{return D.focusedIndex=q,D},u=(D,q,G=!0)=>{if(q===0)return D;let j=D.focusedIndex-1;if(j<0)j=G?q-1:0;return D.focusedIndex=j,D},v=(D,q,G=!0)=>{if(q===0)return D;let j=D.focusedIndex+1;if(j>=q)j=G?0:q-1;return D.focusedIndex=j,D},R=(D,q)=>{if(q===0)return D;return D.focusedIndex=0,D},S=(D,q)=>{if(q===0)return D;return D.focusedIndex=q-1,D},r=(D,q,G,j)=>{if(q===0)return D;let J=j==="up"?D.focusedIndex-G:D.focusedIndex+G;return J=Math.max(0,Math.min(q-1,J)),D.focusedIndex=J,D},m=(D,q)=>{return D.selected.has(q)},y=(D)=>{return Array.from(D.selected)},O=(D,q)=>{let G=[];for(let j of D.selected){let J=q(j);if(J)G.push(J)}return G},d=(D)=>{return D.selected.size},l=(D)=>{return D.selected.size===0},c=(D,q,G)=>{if(G==="none"||D.focusedIndex<0||D.focusedIndex>=q.length)return D;let j=q[D.focusedIndex];if(!j)return D;return V(D,j.id,G)},o=(D,q,G,j,J)=>{if(J!=="multiple")return D;let B=Math.min(G,j),X=Math.max(G,j),U=[];for(let $=B;$<=X;$++){let k=q[$];if(k)U.push(k.id)}return E(D,U,J)};var h=(D,q,G,j,J,B)=>{if(j===0)return 0;let X=Math.max(0,Math.min(D,j-1)),U=q.getOffset(X),$=q.getHeight(X),k=q.getTotalHeight(),T=Math.max(0,k-G),W;switch(B){case"center":W=U-G/2+$/2;break;case"end":W=U-G+$;break;case"start":default:W=U;break}return Math.max(0,Math.min(W,T))};var p=(D,q,G,j,J="start",B,X=h)=>{return X(D,q,G,j,B,J)};var n=(D)=>{let q=D?.mode??"single",G=D?.initial,j=H(G),J=null;return{name:"withSelection",priority:50,methods:["select","deselect","toggleSelect","selectAll","clearSelection","getSelected","getSelectedItems"],setup(B){let{dom:X,emitter:U,config:$}=B,{classPrefix:k,ariaIdPrefix:T}=$;if(q==="none"){B.methods.set("select",()=>{}),B.methods.set("deselect",()=>{}),B.methods.set("toggleSelect",()=>{}),B.methods.set("selectAll",()=>{}),B.methods.set("clearSelection",()=>{}),B.methods.set("getSelected",()=>[]),B.methods.set("getSelectedItems",()=>[]),B.methods.set("setSelectionMode",()=>{});return}let{renderIfNeeded:W,forceRender:g}=B.getRenderFns(),b=()=>{B.dom.items.querySelectorAll("[data-index]").forEach((Q)=>{let M=Q,L=M.dataset.id;if(L!==void 0){let Y=/^\d+$/.test(L)?parseInt(L,10):L,_=j.selected.has(Y),N=parseInt(M.dataset.index??"-1",10)===j.focusedIndex;M.classList.toggle(`${k}-item--selected`,_),M.classList.toggle(`${k}-item--focused`,N),M.ariaSelected=_?"true":"false"}})},x=()=>{if(B.state.isDestroyed)return;W(),b()},I=()=>{if(B.state.isDestroyed)return;g(),b()};B.setRenderFns(x,I);let A=()=>{b(),U.emit("selection:change",{selected:y(j),items:O(j,(K)=>B.dataManager.getItemById(K))})};J=document.createElement("div"),J.setAttribute("aria-live","polite"),J.setAttribute("aria-atomic","true"),J.className=`${k}-live-region`,J.style.cssText="position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0",X.root.appendChild(J);let z=J;U.on("selection:change",({selected:K})=>{let Q=K.length;if(Q===0)z.textContent="";else if(Q===1)z.textContent="1 item selected";else z.textContent=`${Q} items selected`}),B.clickHandlers.push((K)=>{if(B.state.isDestroyed)return;let M=K.target.closest("[data-index]");if(!M)return;let L=parseInt(M.dataset.index??"-1",10);if(L<0)return;let Y=B.dataManager.getItem(L);if(!Y)return;U.emit("item:click",{item:Y,index:L,event:K}),j=w(j,L),X.root.setAttribute("aria-activedescendant",`${T}-item-${L}`),j=V(j,Y.id,q),A()}),B.keydownHandlers.push((K)=>{if(B.state.isDestroyed)return;let Q=B.dataManager.getTotal(),M=j.focusedIndex,L=!1,Y=!1,_=j;switch(K.key){case"ArrowUp":_=u(j,Q),L=!0,Y=!0;break;case"ArrowDown":_=v(j,Q),L=!0,Y=!0;break;case"Home":_=R(j,Q),L=!0,Y=!0;break;case"End":_=S(j,Q),L=!0,Y=!0;break;case" ":case"Enter":if(j.focusedIndex>=0){let Z=B.dataManager.getItem(j.focusedIndex);if(Z)_=V(j,Z.id,q);L=!0}break}if(L){K.preventDefault(),j=_;let Z=j.focusedIndex;if(Z>=0){let N=B.dataManager.getState(),P=p(Z,B.heightCache,B.state.viewportState.containerHeight,N.total,"center",B.getCachedCompression());B.scrollController.scrollTo(P),X.root.setAttribute("aria-activedescendant",`${T}-item-${Z}`)}else X.root.removeAttribute("aria-activedescendant");if(Y){let{selected:N}=j;if(M>=0&&M!==Z){let P=B.dataManager.getItem(M);if(P)B.renderer.updateItemClasses(M,N.has(P.id),!1)}if(Z>=0){let P=B.dataManager.getItem(Z);if(P)B.renderer.updateItemClasses(Z,N.has(P.id),!0)}}else I(),U.emit("selection:change",{selected:y(j),items:O(j,(N)=>B.dataManager.getItemById(N))})}}),B.methods.set("select",(...K)=>{if(q==="none")return;j=E(j,K,q),A()}),B.methods.set("deselect",(...K)=>{j=F(j,K),A()}),B.methods.set("toggleSelect",(K)=>{if(q==="none")return;j=V(j,K,q),A()}),B.methods.set("selectAll",()=>{if(q!=="multiple")return;let K=B.getAllLoadedItems();j=C(j,K,q),A()}),B.methods.set("clearSelection",()=>{j=f(j);let{renderRange:K,isCompressed:Q}=B.state.viewportState,M=B.getItemsForRange(K),L=Q?B.getCompressionContext():void 0;B.renderer.render(M,K,j.selected,j.focusedIndex,L),U.emit("selection:change",{selected:[],items:[]})}),B.methods.set("getSelected",()=>{return y(j)}),B.methods.set("getSelectedItems",()=>{return O(j,(K)=>B.dataManager.getItemById(K))}),B.destroyHandlers.push(()=>{if(z&&z.parentNode)z.remove()})},destroy(){if(J&&J.parentNode)J.remove();J=null}}};export{n as withSelection,V as toggleSelection,w as setFocusedIndex,o as selectRange,E as selectItems,c as selectFocused,C as selectAll,u as moveFocusUp,S as moveFocusToLast,R as moveFocusToFirst,v as moveFocusDown,r as moveFocusByPage,l as isSelectionEmpty,m as isSelected,d as getSelectionCount,O as getSelectedItems,y as getSelectedIds,F as deselectItems,H as createSelectionState,f as clearSelection};