@glhrmoura/vue-virtualize 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Guilherme Moura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+<p align="center">
+  <img src="docs/public/logo.png" alt="" width="144" height="96" />
+</p>
+
+# Vue Virtualize
+
+Headless virtualization for Vue 3 lists, grids, and tables.
+
+[![License](https://img.shields.io/npm/l/@glhrmoura/vue-virtualize.svg?style=for-the-badge)](https://github.com/glhrmoura/vue-virtualize/blob/main/LICENSE)
+
+`@glhrmoura/vue-virtualize` mounts only the items that intersect the viewport. The layout engine is plain TypeScript: it does not import Vue and it does not touch the DOM. Components and composables subscribe to scroll and resize, then render the window the engine returns.
+
+## Features
+
+- Vertical and horizontal lists
+- Two-axis grids
+- Tables with virtualized rows and placed columns
+- Configurable overscan
+- Fixed estimates and measured dynamic sizes
+- Programmatic `scrollToIndex` and `scrollToOffset`
+- Reactive updates when the collection changes
+- Container resize handling and listener cleanup
+- Empty states and stable item keys
+- SSR-safe: no browser APIs at import time
+- TypeScript generics for item types
+
+## Install
+
+```bash
+yarn add @glhrmoura/vue-virtualize
+```
+
+```bash
+npm install @glhrmoura/vue-virtualize
+```
+
+Vue 3.5+ is a peer dependency.
+
+## Quick start
+
+```vue
+<script setup lang="ts">
+import { VirtualList } from '@glhrmoura/vue-virtualize'
+import { shallowRef } from 'vue'
+
+interface User {
+  id: number
+  name: string
+}
+
+const users = shallowRef<User[]>(
+  Array.from({ length: 100_000 }, (_, index) => ({
+    id: index + 1,
+    name: `User ${index + 1}`,
+  })),
+)
+</script>
+
+<template>
+  <VirtualList :items="users" :estimate-size="60" :height="500" :get-item-key="(user) => user.id">
+    <template #default="{ item, index }">
+      <UserCard :user="item" :index="index" />
+    </template>
+  </VirtualList>
+</template>
+```
+
+## Examples
+
+| Component        | Use                                                    |
+| ---------------- | ------------------------------------------------------ |
+| `VirtualList`    | One axis, vertical or `horizontal`                     |
+| `VirtualGrid`    | Flat array, `columnCount`, row and column estimates    |
+| `VirtualTable`   | `rows`, `columns`, windowed body                       |
+| `useVirtualizer` | Custom markup driven by `virtualItems` and `totalSize` |
+
+The playground (`yarn dev`) includes 1,000, 10,000, and 100,000 row lists, a measured-height list, a grid, and a table.
+
+## Documentation
+
+Guides and the API reference live in `docs/` and are built with VitePress:
+
+```bash
+yarn docs:dev
+```
+
+## Scripts
+
+```bash
+yarn test
+yarn typecheck
+yarn lint
+yarn build
+yarn bench
+```
+
+`yarn bench` measures the engine locally. This repository does not publish benchmark numbers.
+
+## Publishing
+
+Changesets tracks versions. CI runs lint, typecheck, tests, and the library build. Publishing to npm is a manual step after `yarn build`. The package name is `@glhrmoura/vue-virtualize`.
+
+## Contributing
+
+1. Install dependencies with yarn (`packageManager` is pinned in `package.json`).
+2. Branch from the default branch.
+3. Add a changeset when the public API or behavior changes.
+4. Run `yarn lint`, `yarn typecheck`, `yarn test`, and `yarn build`.
+
+## License
+
+MIT

package/dist/components/VirtualGrid.vue.d.ts

@@ -0,0 +1,53 @@
+import { type HTMLAttributes } from 'vue';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        items: readonly T[];
+        columnCount?: number;
+        estimateRowSize?: number | ((rowIndex: number) => number);
+        estimateColumnSize?: number | ((columnIndex: number) => number);
+        height?: number | string;
+        width?: number | string;
+        overscan?: number;
+        overscanRows?: number;
+        overscanColumns?: number;
+        rowGap?: number;
+        columnGap?: number;
+        getItemKey?: (item: T, index: number) => string | number;
+        tag?: string;
+        itemAttrs?: HTMLAttributes;
+        revision?: unknown;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        scrollToIndex: (index: number, scrollOptions?: import("..").ScrollToIndexOptions) => void;
+        scrollToOffset: (offset: {
+            top?: number;
+            left?: number;
+        }, behavior?: ScrollBehavior) => void;
+        measureRow: (rowIndex: number, size: number) => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        empty?: (props: {}) => any;
+    } & {
+        default?: (props: {
+            item: T;
+            index: number;
+            rowIndex: number;
+            columnIndex: number;
+            row: import("..").VirtualItem;
+            column: import("..").VirtualItem;
+        }) => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/VirtualList.vue.d.ts

@@ -0,0 +1,48 @@
+import { type HTMLAttributes } from 'vue';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        items: readonly T[];
+        estimateSize?: number | ((index: number, item: T) => number);
+        height?: number | string;
+        width?: number | string;
+        horizontal?: boolean;
+        overscan?: number;
+        gap?: number;
+        paddingStart?: number;
+        paddingEnd?: number;
+        getItemKey?: (item: T, index: number) => string | number;
+        tag?: string;
+        itemTag?: string;
+        itemAttrs?: HTMLAttributes;
+        revision?: unknown;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        scrollToIndex: (index: number, scrollOptions?: import("..").ScrollToIndexOptions) => void;
+        scrollToOffset: (offset: number, behavior?: ScrollBehavior) => void;
+        measure: (index: number, size: number) => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        empty?: (props: {}) => any;
+    } & {
+        default?: (props: {
+            item: T;
+            index: number;
+            start: number;
+            size: number;
+            end: number;
+        }) => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/VirtualTable.vue.d.ts

@@ -0,0 +1,49 @@
+import { type HTMLAttributes } from 'vue';
+import { type VirtualTableColumn } from '../composables/useVirtualTable';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        rows: readonly T[];
+        columns: readonly VirtualTableColumn<T>[];
+        estimateRowSize?: number | ((index: number, row: T) => number);
+        height?: number | string;
+        width?: number | string;
+        overscan?: number;
+        getRowKey?: (row: T, index: number) => string | number;
+        stickyHeader?: boolean;
+        tag?: string;
+        rowAttrs?: HTMLAttributes;
+        revision?: unknown;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        scrollToIndex: (index: number, scrollOptions?: import("..").ScrollToIndexOptions) => void;
+        scrollToOffset: (offset: number, behavior?: ScrollBehavior) => void;
+        measure: (index: number, size: number) => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        header?: (props: {
+            columns: import("..").PlacedVirtualTableColumn<T>[];
+        }) => any;
+    } & {
+        empty?: (props: {}) => any;
+    } & {
+        cell?: (props: {
+            row: T;
+            column: import("..").PlacedVirtualTableColumn<T>;
+            rowIndex: number;
+            value: unknown;
+        }) => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/composables/useVirtualGrid.d.ts

@@ -0,0 +1,40 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { ScrollToIndexOptions, VirtualItem } from '../core/types';
+import { type UseVirtualizerOptions } from './useVirtualizer';
+export interface VirtualGridCell<T> {
+    index: number;
+    key: string | number;
+    item: T;
+    row: VirtualItem;
+    column: VirtualItem;
+}
+export interface UseVirtualGridOptions<T> {
+    items: MaybeRefOrGetter<readonly T[]>;
+    columnCount: MaybeRefOrGetter<number>;
+    estimateRowSize?: MaybeRefOrGetter<number | ((rowIndex: number) => number)>;
+    estimateColumnSize?: MaybeRefOrGetter<number | ((columnIndex: number) => number)>;
+    container?: UseVirtualizerOptions['container'];
+    overscan?: MaybeRefOrGetter<number | undefined>;
+    overscanRows?: MaybeRefOrGetter<number | undefined>;
+    overscanColumns?: MaybeRefOrGetter<number | undefined>;
+    rowGap?: MaybeRefOrGetter<number | undefined>;
+    columnGap?: MaybeRefOrGetter<number | undefined>;
+    getItemKey?: (item: T, index: number) => string | number;
+    initialRect?: UseVirtualizerOptions['initialRect'];
+    revision?: UseVirtualizerOptions['revision'];
+}
+export declare function useVirtualGrid<T>(options: UseVirtualGridOptions<T>): {
+    virtualRows: import("vue").ComputedRef<VirtualItem[]>;
+    virtualColumns: import("vue").ComputedRef<VirtualItem[]>;
+    virtualCells: import("vue").ComputedRef<VirtualGridCell<T>[]>;
+    totalHeight: import("vue").ComputedRef<number>;
+    totalWidth: import("vue").ComputedRef<number>;
+    scrollToIndex: (index: number, scrollOptions?: ScrollToIndexOptions) => void;
+    scrollToOffset: (offset: {
+        top?: number;
+        left?: number;
+    }, behavior?: ScrollBehavior) => void;
+    measureRow: (rowIndex: number, size: number) => void;
+    measureRowElement: (target: unknown, rowIndex: number) => void;
+    measureColumn: (index: number, size: number) => void;
+};

package/dist/composables/useVirtualList.d.ts

@@ -0,0 +1,31 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { VirtualItem } from '../core/types';
+import { type UseVirtualizerOptions } from './useVirtualizer';
+export interface VirtualListItem<T> extends VirtualItem {
+    item: T;
+}
+export interface UseVirtualListOptions<T> {
+    items: MaybeRefOrGetter<readonly T[]>;
+    estimateSize?: number | ((index: number, item: T) => number);
+    container?: UseVirtualizerOptions['container'];
+    horizontal?: UseVirtualizerOptions['horizontal'];
+    overscan?: UseVirtualizerOptions['overscan'];
+    gap?: UseVirtualizerOptions['gap'];
+    paddingStart?: UseVirtualizerOptions['paddingStart'];
+    paddingEnd?: UseVirtualizerOptions['paddingEnd'];
+    itemSize?: UseVirtualizerOptions['itemSize'];
+    getItemKey?: (item: T, index: number) => string | number;
+    initialRect?: UseVirtualizerOptions['initialRect'];
+    viewportInset?: UseVirtualizerOptions['viewportInset'];
+    revision?: UseVirtualizerOptions['revision'];
+}
+export declare function useVirtualList<T>(options: UseVirtualListOptions<T>): {
+    virtualItems: import("vue").ComputedRef<VirtualListItem<T>[]>;
+    totalSize: import("vue").ComputedRef<number>;
+    scrollOffset: import("vue").ComputedRef<number>;
+    isScrolling: import("vue").ComputedRef<boolean>;
+    scrollToIndex: (index: number, scrollOptions?: import("..").ScrollToIndexOptions) => void;
+    scrollToOffset: (offset: number, behavior?: ScrollBehavior) => void;
+    measure: (index: number, size: number) => void;
+    measureElement: (target: unknown, index: number) => void;
+};

package/dist/composables/useVirtualTable.d.ts

@@ -0,0 +1,39 @@
+import { type MaybeRefOrGetter } from 'vue';
+import { type UseVirtualListOptions, type VirtualListItem } from './useVirtualList';
+export interface VirtualTableColumn<T> {
+    id: string;
+    header: string;
+    width?: number;
+    minWidth?: number;
+    align?: 'left' | 'center' | 'right';
+    accessor?: (row: T, index: number) => unknown;
+}
+export interface PlacedVirtualTableColumn<T> extends VirtualTableColumn<T> {
+    start: number;
+    size: number;
+    end: number;
+}
+export interface UseVirtualTableOptions<T> {
+    rows: MaybeRefOrGetter<readonly T[]>;
+    columns: MaybeRefOrGetter<readonly VirtualTableColumn<T>[]>;
+    estimateRowSize?: number | ((index: number, row: T) => number);
+    container?: UseVirtualListOptions<T>['container'];
+    overscan?: UseVirtualListOptions<T>['overscan'];
+    getRowKey?: (row: T, index: number) => string | number;
+    initialRect?: UseVirtualListOptions<T>['initialRect'];
+    viewportInset?: UseVirtualListOptions<T>['viewportInset'];
+    revision?: UseVirtualListOptions<T>['revision'];
+    itemSize?: UseVirtualListOptions<T>['itemSize'];
+}
+export declare function useVirtualTable<T>(options: UseVirtualTableOptions<T>): {
+    virtualRows: import("vue").ComputedRef<VirtualListItem<T>[]>;
+    columns: import("vue").ComputedRef<PlacedVirtualTableColumn<T>[]>;
+    totalHeight: import("vue").ComputedRef<number>;
+    totalWidth: import("vue").ComputedRef<number>;
+    scrollOffset: import("vue").ComputedRef<number>;
+    isScrolling: import("vue").ComputedRef<boolean>;
+    scrollToIndex: (index: number, scrollOptions?: import("..").ScrollToIndexOptions) => void;
+    scrollToOffset: (offset: number, behavior?: ScrollBehavior) => void;
+    measure: (index: number, size: number) => void;
+    measureElement: (target: unknown, index: number) => void;
+};

package/dist/composables/useVirtualizer.d.ts

@@ -0,0 +1,31 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { ScrollToIndexOptions, VirtualItem } from '../core/types';
+export interface UseVirtualizerOptions {
+    count: MaybeRefOrGetter<number>;
+    estimateSize: (index: number) => number;
+    container?: MaybeRefOrGetter<HTMLElement | null | undefined>;
+    horizontal?: MaybeRefOrGetter<boolean>;
+    overscan?: MaybeRefOrGetter<number>;
+    gap?: MaybeRefOrGetter<number>;
+    paddingStart?: MaybeRefOrGetter<number>;
+    paddingEnd?: MaybeRefOrGetter<number>;
+    lanes?: MaybeRefOrGetter<number>;
+    itemSize?: MaybeRefOrGetter<number | null | undefined>;
+    getItemKey?: (index: number) => string | number;
+    initialRect?: MaybeRefOrGetter<{
+        width: number;
+        height: number;
+    } | undefined>;
+    viewportInset?: MaybeRefOrGetter<number>;
+    revision?: MaybeRefOrGetter<unknown>;
+}
+export declare function useVirtualizer(options: UseVirtualizerOptions): {
+    virtualItems: import("vue").ComputedRef<VirtualItem[]>;
+    totalSize: import("vue").ComputedRef<number>;
+    scrollOffset: import("vue").ComputedRef<number>;
+    isScrolling: import("vue").ComputedRef<boolean>;
+    scrollToIndex: (index: number, scrollOptions?: ScrollToIndexOptions) => void;
+    scrollToOffset: (offset: number, behavior?: ScrollBehavior) => void;
+    measure: (index: number, size: number) => void;
+    measureElement: (target: unknown, index: number) => void;
+};

package/dist/core/measurements.d.ts

@@ -0,0 +1,10 @@
+export declare function normalizeSize(size: number): number;
+export declare class MeasurementCache {
+    private readonly sizes;
+    private divergent;
+    get(index: number): number | undefined;
+    set(index: number, size: number, baseline: number | null): void;
+    get hasDivergent(): boolean;
+    clear(): void;
+    trim(count: number, baseline: number | null): void;
+}

package/dist/core/scrolling.d.ts

@@ -0,0 +1,11 @@
+import type { ScrollAlignment } from './types';
+export declare function clampScrollOffset(offset: number, totalSize: number, viewport: number): number;
+export declare function findFirstIndexPast(count: number, target: number, getEnd: (index: number) => number): number;
+export declare function findLastIndexBefore(count: number, target: number, getStart: (index: number) => number): number;
+export declare function resolveScrollOffset(input: {
+    start: number;
+    size: number;
+    viewport: number;
+    current: number;
+    align: ScrollAlignment;
+}): number;

package/dist/core/types.d.ts

@@ -0,0 +1,25 @@
+export type ScrollAlignment = 'start' | 'center' | 'end' | 'auto';
+export interface VirtualItem {
+    index: number;
+    key: string | number;
+    start: number;
+    size: number;
+    end: number;
+    lane: number;
+}
+export interface VirtualizerOptions {
+    count: number;
+    estimateSize: (index: number) => number;
+    overscan?: number;
+    gap?: number;
+    paddingStart?: number;
+    paddingEnd?: number;
+    lanes?: number;
+    itemSize?: number | null;
+    viewportSize?: number;
+    getItemKey?: (index: number) => string | number;
+}
+export interface ScrollToIndexOptions {
+    align?: ScrollAlignment;
+    behavior?: ScrollBehavior;
+}

package/dist/core/virtualizer.d.ts

@@ -0,0 +1,35 @@
+import type { ScrollAlignment, VirtualItem, VirtualizerOptions } from './types';
+export declare class Virtualizer {
+    private count;
+    private estimateSize;
+    private overscan;
+    private gap;
+    private paddingStart;
+    private paddingEnd;
+    private lanes;
+    private itemSize;
+    private viewportSize;
+    private scrollOffset;
+    private getItemKey;
+    private readonly measurements;
+    private built;
+    private offsets;
+    private laneCursor;
+    private laneEnd;
+    setOptions(options: VirtualizerOptions): void;
+    setScrollOffset(offset: number): void;
+    getScrollOffset(): number;
+    getViewportSize(): number;
+    measure(index: number, size: number): boolean;
+    clearMeasurements(): void;
+    getItemSize(index: number): number;
+    getItemOffset(index: number): number;
+    getTotalSize(): number;
+    getVirtualItems(): VirtualItem[];
+    getOffsetForIndex(index: number, align?: ScrollAlignment): number;
+    private usesFixedPath;
+    private ordinalIndex;
+    private laneLength;
+    private ensure;
+    private resetGeometry;
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { Virtualizer } from './core/virtualizer';
+export { MeasurementCache, normalizeSize } from './core/measurements';
+export { clampScrollOffset, resolveScrollOffset } from './core/scrolling';
+export type { ScrollAlignment, ScrollToIndexOptions, VirtualItem, VirtualizerOptions, } from './core/types';
+export { useVirtualizer } from './composables/useVirtualizer';
+export type { UseVirtualizerOptions } from './composables/useVirtualizer';
+export { useVirtualList } from './composables/useVirtualList';
+export type { UseVirtualListOptions, VirtualListItem } from './composables/useVirtualList';
+export { useVirtualGrid } from './composables/useVirtualGrid';
+export type { UseVirtualGridOptions, VirtualGridCell } from './composables/useVirtualGrid';
+export { useVirtualTable } from './composables/useVirtualTable';
+export type { PlacedVirtualTableColumn, UseVirtualTableOptions, VirtualTableColumn, } from './composables/useVirtualTable';
+export { default as VirtualList } from './components/VirtualList.vue';
+export { default as VirtualGrid } from './components/VirtualGrid.vue';
+export { default as VirtualTable } from './components/VirtualTable.vue';

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("vue");function K(e){return!Number.isFinite(e)||e<0?0:e}class Z{sizes=new Map;divergent=!1;get(n){return this.sizes.get(n)}set(n,i,r){this.sizes.set(n,i),r!==null&&Math.abs(i-r)>=.5&&(this.divergent=!0)}get hasDivergent(){return this.divergent}clear(){this.sizes.clear(),this.divergent=!1}trim(n,i){let r=!1;for(const s of this.sizes.keys())s>=n&&(this.sizes.delete(s),r=!0);if(r&&(this.divergent=!1,i!==null)){for(const s of this.sizes.values())if(Math.abs(s-i)>=.5){this.divergent=!0;return}}}}function ee(e,n,i){return Math.min(i,Math.max(n,e))}function G(e,n,i){const r=Math.max(0,n-Math.max(0,i));return ee(Number.isFinite(e)?e:0,0,r)}function le(e,n,i){if(e<=0)return 0;let r=0,s=e-1,o=e-1;for(;r<=s;){const d=r+s>>>1;i(d)>n?(o=d,s=d-1):r=d+1}return o}function ue(e,n,i){if(e<=0)return 0;let r=0,s=e-1,o=0;for(;r<=s;){const d=r+s>>>1;i(d)<n?(o=d,r=d+1):s=d-1}return o}function te(e){const n=e.start+e.size;let i=e.align;if(i==="auto"){const r=e.current+e.viewport;if(e.start>=e.current&&n<=r)return e.current;i=e.start<e.current?"start":"end"}return i==="center"?e.start-(e.viewport-e.size)/2:i==="end"?n-e.viewport:e.start}class ne{count=0;estimateSize=()=>0;overscan=0;gap=0;paddingStart=0;paddingEnd=0;lanes=1;itemSize=null;viewportSize=0;scrollOffset=0;getItemKey=n=>n;measurements=new Z;built=0;offsets=[];laneCursor=[];laneEnd=[];setOptions(n){const i=Math.max(1,Math.floor(n.lanes??1)),r=n.gap??0,s=n.paddingStart??0,o=n.paddingEnd??0,d=Math.max(0,Math.floor(n.count)),h=n.itemSize===void 0||n.itemSize===null?null:K(n.itemSize),y=this.itemSize,x=i!==this.lanes||r!==this.gap||s!==this.paddingStart||o!==this.paddingEnd||n.estimateSize!==this.estimateSize||h!==this.itemSize;this.count=d,this.lanes=i,this.gap=r,this.paddingStart=s,this.paddingEnd=o,this.overscan=Math.max(0,Math.floor(n.overscan??0)),this.estimateSize=n.estimateSize,this.itemSize=h,this.getItemKey=n.getItemKey??(v=>v),n.viewportSize!==void 0&&(this.viewportSize=Math.max(0,n.viewportSize)),h!==y&&this.measurements.clear(),this.measurements.trim(this.count,this.itemSize),(x||this.built>this.count)&&this.resetGeometry()}setScrollOffset(n){this.scrollOffset=Number.isFinite(n)?n:0}getScrollOffset(){return this.scrollOffset}getViewportSize(){return this.viewportSize}measure(n,i){if(n<0||n>=this.count)return!1;const r=K(i),s=this.measurements.get(n);if(s!==void 0&&Math.abs(s-r)<.5)return!1;const o=this.getItemSize(n);return this.measurements.set(n,r,this.itemSize),Math.abs(o-r)<.5?!1:(this.resetGeometry(),!0)}clearMeasurements(){this.measurements.clear(),this.resetGeometry()}getItemSize(n){const i=this.measurements.get(n);return i!==void 0?i:this.itemSize!==null?this.itemSize:K(this.estimateSize(n))}getItemOffset(n){if(n<=0||this.count<=0)return this.paddingStart;const i=Math.min(n,this.count-1);if(this.usesFixedPath()){const r=Math.floor(i/this.lanes);return this.paddingStart+r*((this.itemSize??0)+this.gap)}return this.ensure(i),this.offsets[i]??this.paddingStart}getTotalSize(){if(this.count<=0)return this.paddingStart+this.paddingEnd;if(this.usesFixedPath()){let i=this.paddingStart;const r=this.itemSize??0;for(let s=0;s<this.lanes&&s<this.count;s+=1){const o=this.laneLength(s),d=this.paddingStart+o*r+Math.max(0,o-1)*this.gap;d>i&&(i=d)}return i+this.paddingEnd}this.ensure(this.count-1);let n=this.paddingStart;for(let i=0;i<this.lanes&&i<this.count;i+=1){const r=this.laneEnd[i]??this.paddingStart;r>n&&(n=r)}return n+this.paddingEnd}getVirtualItems(){if(this.count<=0||this.viewportSize<=0)return[];const n=G(this.scrollOffset,this.getTotalSize(),this.viewportSize),i=n+this.viewportSize,r=[];for(let s=0;s<this.lanes;s+=1){const o=this.laneLength(s);if(o<=0)continue;const d=le(o,n,v=>{const p=this.ordinalIndex(s,v);return this.getItemOffset(p)+this.getItemSize(p)}),h=ue(o,i,v=>this.getItemOffset(this.ordinalIndex(s,v))),y=Math.max(0,Math.min(d,h)-this.overscan),x=Math.min(o-1,Math.max(d,h)+this.overscan);for(let v=y;v<=x;v+=1){const p=this.ordinalIndex(s,v),I=this.getItemOffset(p),E=this.getItemSize(p);r.push({index:p,key:this.getItemKey(p),start:I,size:E,end:I+E,lane:s})}}return r.sort((s,o)=>s.index-o.index),r}getOffsetForIndex(n,i="auto"){if(this.count<=0)return 0;const r=ee(n,0,this.count-1),s=this.getItemOffset(r),o=this.getItemSize(r),d=te({start:s,size:o,viewport:this.viewportSize,current:this.scrollOffset,align:i});return G(d,this.getTotalSize(),this.viewportSize)}usesFixedPath(){return this.itemSize!==null&&!this.measurements.hasDivergent}ordinalIndex(n,i){return n+i*this.lanes}laneLength(n){return n<0||n>=this.lanes||n>=this.count?0:Math.floor((this.count-n-1)/this.lanes)+1}ensure(n){if(n<this.built)return;const i=Math.min(n,this.count-1);for(;this.built<=i;){const r=this.built%this.lanes,s=this.laneCursor[r]??this.paddingStart;this.offsets[this.built]=s;const o=s+this.getItemSize(this.built);this.laneEnd[r]=o,this.laneCursor[r]=o+this.gap,this.built+=1}}resetGeometry(){this.built=0,this.offsets=[],this.laneCursor=Array.from({length:this.lanes},()=>this.paddingStart),this.laneEnd=Array.from({length:this.lanes},()=>this.paddingStart)}}function F(){return typeof window<"u"&&typeof document<"u"}function ie(e){return typeof Element>"u"?null:e instanceof Element?e:null}function N(e,n,i,r){if(r==="smooth"&&typeof e.scrollTo=="function"){e.scrollTo({top:i?e.scrollTop:n,left:i?n:e.scrollLeft,behavior:r});return}i?e.scrollLeft=n:e.scrollTop=n}function P(e,n){return n?e.scrollLeft:e.scrollTop}function U(e,n){return n?e.clientWidth:e.clientHeight}function Y(e){return typeof requestAnimationFrame=="function"?requestAnimationFrame(e):setTimeout(e,0)}function X(e){e&&(typeof cancelAnimationFrame=="function"?cancelAnimationFrame(e):clearTimeout(e))}function ce(e,n){if(e.length!==n.length)return!1;for(let i=0;i<e.length;i+=1){const r=e[i],s=n[i];if(!r||!s||r.index!==s.index||r.start!==s.start||r.size!==s.size||r.end!==s.end||r.lane!==s.lane||r.key!==s.key)return!1}return!0}function A(e){const n=new ne,i=t.shallowRef([]),r=t.ref(0),s=t.ref(0),o=t.ref(!1),d=c=>e.estimateSize(c);let h=null,y=null,x=null,v=0,p=0,I=0,E=t.toValue(e.revision);const l=new Map,u=new Map,a=[];function f(){const c=t.toValue(e.container);return typeof HTMLElement>"u"?null:c instanceof HTMLElement?c:null}function S(){return t.toValue(e.horizontal)??!1}function C(){const c=t.toValue(e.initialRect);return c?S()?c.width:c.height:0}function O(){const c=t.toValue(e.revision);Object.is(c,E)||(E=c,n.clearMeasurements());const z=f(),w=z?U(z,S()):0,V=t.toValue(e.viewportInset)??0,k=Math.max(0,(w>0?w:C())-V),T=t.toValue(e.itemSize);n.setOptions({count:t.toValue(e.count),estimateSize:d,overscan:t.toValue(e.overscan)??5,gap:t.toValue(e.gap)??0,paddingStart:t.toValue(e.paddingStart)??0,paddingEnd:t.toValue(e.paddingEnd)??0,lanes:t.toValue(e.lanes)??1,itemSize:T??null,getItemKey:e.getItemKey,viewportSize:k});const M=Math.max(0,n.getTotalSize()-k);n.getScrollOffset()>M&&(n.setScrollOffset(M),z&&P(z,S())!==M&&N(z,M,S(),"auto"));const _=n.getVirtualItems();ce(i.value,_)||(i.value=_);const j=n.getTotalSize();r.value!==j&&(r.value=j);const q=n.getScrollOffset();s.value!==q&&(s.value=q)}function $(){if(!F()){O();return}v||(v=Y(()=>{v=0,o.value=!0,O(),typeof window<"u"&&(window.clearTimeout(I),I=window.setTimeout(()=>{o.value=!1},150))}))}function m(){const c=f();c&&(n.setScrollOffset(P(c,S())),$())}function b(){const c=f();if(c===h||(h&&(h.removeEventListener("scroll",m),y?.disconnect(),y=null),h=c,!c||!F()))return;const z=S();n.getScrollOffset()>0?N(c,n.getScrollOffset(),z,"auto"):n.setScrollOffset(P(c,z)),c.addEventListener("scroll",m,{passive:!0}),typeof ResizeObserver<"u"&&(y=new ResizeObserver(()=>O()),y.observe(c))}function g(){return!F()||typeof ResizeObserver>"u"?null:(x||(x=new ResizeObserver(c=>{const z=S();let w=!1;for(const V of c){const k=l.get(V.target);if(k===void 0)continue;const T=V.borderBoxSize?.[0],M=z?T?.inlineSize??V.contentRect.width:T?.blockSize??V.contentRect.height;M>0&&n.measure(k,M)&&(w=!0)}w&&O()})),x)}function R(){p=0;const c=a.splice(0,a.length),z=S();let w=!1;for(const V of c){if(!V.element.isConnected)continue;const k=V.element.getBoundingClientRect(),T=z?k.width:k.height;T>0&&n.measure(V.index,T)&&(w=!0)}w&&O()}function L(c,z){const w=ie(c),V=g(),k=u.get(z);k&&k!==w&&(V?.unobserve(k),l.delete(k),u.delete(z)),w&&(u.set(z,w),l.set(w,z),V?.observe(w),a.push({element:w,index:z}),!p&&(p=Y(R)))}function W(c,z="auto"){const w=f(),V=w?U(w,S()):0,k=V>0?V:n.getViewportSize(),T=G(c,n.getTotalSize(),k);n.setScrollOffset(T),w&&N(w,T,S(),z),O()}function oe(c,z){const w=n.getOffsetForIndex(c,z?.align??"auto");W(w,z?.behavior??"auto")}function ae(c,z){n.measure(c,z)&&O()}return O(),t.watch(()=>[t.toValue(e.count),t.toValue(e.overscan),t.toValue(e.gap),t.toValue(e.paddingStart),t.toValue(e.paddingEnd),t.toValue(e.lanes),t.toValue(e.horizontal),t.toValue(e.itemSize),t.toValue(e.viewportInset),t.toValue(e.revision),t.toValue(e.container),t.toValue(e.initialRect)?.width,t.toValue(e.initialRect)?.height],()=>{b(),O()},{flush:"post"}),t.onBeforeUnmount(()=>{h&&h.removeEventListener("scroll",m),y?.disconnect(),x?.disconnect(),X(v),X(p),typeof window<"u"&&window.clearTimeout(I),l.clear(),u.clear(),a.length=0}),{virtualItems:t.computed(()=>i.value),totalSize:t.computed(()=>r.value),scrollOffset:t.computed(()=>s.value),isScrolling:t.computed(()=>o.value),scrollToIndex:oe,scrollToOffset:W,measure:ae,measureElement:L}}function de(e,n,i){return typeof e=="function"?e(n,i):typeof e=="number"?e:48}function H(e){const n=A({count:()=>t.toValue(e.items).length,estimateSize:r=>{const s=t.toValue(e.items);return de(e.estimateSize,r,s[r])},getItemKey:r=>{const o=t.toValue(e.items)[r];return e.getItemKey?.(o,r)??r},itemSize:()=>e.itemSize!==void 0?t.toValue(e.itemSize):typeof e.estimateSize=="number"?e.estimateSize:void 0,container:e.container,horizontal:e.horizontal,overscan:e.overscan,gap:e.gap,paddingStart:e.paddingStart,paddingEnd:e.paddingEnd,initialRect:e.initialRect,viewportInset:e.viewportInset,revision:e.revision});return{virtualItems:t.computed(()=>{const r=t.toValue(e.items);return n.virtualItems.value.map(s=>{const o=r[s.index];return{...s,item:o,key:e.getItemKey?.(o,s.index)??s.key}})}),totalSize:n.totalSize,scrollOffset:n.scrollOffset,isScrolling:n.isScrolling,scrollToIndex:n.scrollToIndex,scrollToOffset:n.scrollToOffset,measure:n.measure,measureElement:n.measureElement}}function J(e,n,i){return typeof e=="function"?e(n):typeof e=="number"?e:i}function re(e){const n=t.computed(()=>Math.max(1,Math.floor(t.toValue(e.columnCount)||1))),i=t.computed(()=>Math.ceil(t.toValue(e.items).length/n.value)),r=new Map,s=A({count:()=>i.value,estimateSize:l=>J(t.toValue(e.estimateRowSize),l,48),itemSize:()=>{const l=t.toValue(e.estimateRowSize);return typeof l=="number"?l:void 0},overscan:()=>t.toValue(e.overscanRows)??t.toValue(e.overscan)??2,gap:()=>t.toValue(e.rowGap)??0,horizontal:!1,container:e.container,initialRect:e.initialRect,revision:e.revision}),o=A({count:()=>n.value,estimateSize:l=>J(t.toValue(e.estimateColumnSize),l,160),itemSize:()=>{const l=t.toValue(e.estimateColumnSize);return typeof l=="number"?l:void 0},overscan:()=>t.toValue(e.overscanColumns)??t.toValue(e.overscan)??1,gap:()=>t.toValue(e.columnGap)??0,horizontal:!0,container:e.container,initialRect:e.initialRect,revision:e.revision}),d=t.computed(()=>{const l=t.toValue(e.items),u=n.value,a=[];for(const f of s.virtualItems.value)for(const S of o.virtualItems.value){const C=f.index*u+S.index;if(C>=l.length)continue;const O=l[C];a.push({index:C,key:e.getItemKey?.(O,C)??C,item:O,row:f,column:S})}return a});function h(l,u){const a=t.toValue(e.items);if(!a.length)return;const f=Math.min(Math.max(l,0),a.length-1),S=n.value;s.scrollToIndex(Math.floor(f/S),u),o.scrollToIndex(f%S,u)}function y(l,u="auto"){l.top!==void 0&&s.scrollToOffset(l.top,u),l.left!==void 0&&o.scrollToOffset(l.left,u)}function x(l,u){const a=Math.max(r.get(l)??0,u);a<=0||a===r.get(l)||(r.set(l,a),s.measure(l,a))}let v=null;const p=new Map;function I(){return!F()||typeof ResizeObserver>"u"?null:(v||(v=new ResizeObserver(l=>{for(const u of l){const a=p.get(u.target);if(a===void 0)continue;const S=u.borderBoxSize?.[0]?.blockSize??u.contentRect.height;S>0&&x(a,S)}})),v)}function E(l,u){const a=ie(l),f=I();if(!a)return;p.set(a,u),f?.observe(a);const S=a.getBoundingClientRect().height;S>0&&x(u,S)}return t.onBeforeUnmount(()=>{v?.disconnect(),p.clear()}),{virtualRows:s.virtualItems,virtualColumns:o.virtualItems,virtualCells:d,totalHeight:s.totalSize,totalWidth:o.totalSize,scrollToIndex:h,scrollToOffset:y,measureRow:x,measureRowElement:E,measureColumn:o.measure}}function se(e){const n=H({items:e.rows,estimateSize:e.estimateRowSize,container:e.container,overscan:e.overscan,getItemKey:e.getRowKey,initialRect:e.initialRect,viewportInset:e.viewportInset,revision:e.revision,itemSize:e.itemSize}),i=t.computed(()=>{const o=t.toValue(e.columns);let d=0;return o.map(h=>{const y=h.width??h.minWidth??160,x={...h,start:d,size:y,end:d+y};return d+=y,x})}),r=t.computed(()=>{const o=i.value;return o.length?o[o.length-1]?.end??0:0});return{virtualRows:t.computed(()=>n.virtualItems.value),columns:i,totalHeight:n.totalSize,totalWidth:r,scrollOffset:n.scrollOffset,isScrolling:n.isScrolling,scrollToIndex:n.scrollToIndex,scrollToOffset:n.scrollToOffset,measure:n.measure,measureElement:n.measureElement}}function Q(e){if(typeof e=="number"&&Number.isFinite(e))return`${e}px`;if(typeof e=="string"&&e.trim())return e}function B(e){if(typeof e=="number"&&Number.isFinite(e))return e;if(typeof e!="string")return 0;const n=/^(-?\d+(?:\.\d+)?)px$/.exec(e.trim());if(!n?.[1])return 0;const i=Number(n[1]);return Number.isFinite(i)?i:0}function D(e){return{overflow:"auto",position:"relative",height:Q(e.height)??(e.horizontal?"100%":void 0),width:Q(e.width)??(e.horizontal?void 0:"100%"),overflowAnchor:"none"}}function fe(e,n){return{position:"relative",width:n?`${e}px`:"100%",height:n?"100%":`${e}px`}}function me(e,n){return{position:"absolute",top:0,left:0,width:n?void 0:"100%",height:n?"100%":void 0,transform:n?`translateX(${e}px)`:`translateY(${e}px)`}}const he=t.defineComponent({__name:"VirtualList",props:{items:{},estimateSize:{type:[Number,Function],default:48},height:{},width:{},horizontal:{type:Boolean,default:!1},overscan:{default:5},gap:{default:0},paddingStart:{default:0},paddingEnd:{default:0},getItemKey:{},tag:{default:"div"},itemTag:{default:"div"},itemAttrs:{},revision:{}},setup(e,{expose:n}){const i=e,r=t.ref(null),{virtualItems:s,totalSize:o,scrollToIndex:d,scrollToOffset:h,measure:y,measureElement:x}=H({items:()=>i.items,estimateSize:(l,u)=>{const a=i.estimateSize;return typeof a=="number"?a:a(l,u)},itemSize:()=>typeof i.estimateSize=="number"?i.estimateSize:void 0,container:r,horizontal:()=>i.horizontal,overscan:()=>i.overscan,gap:()=>i.gap,paddingStart:()=>i.paddingStart,paddingEnd:()=>i.paddingEnd,getItemKey:(l,u)=>i.getItemKey?.(l,u)??u,initialRect:()=>({width:B(i.width),height:B(i.height)}),revision:()=>i.revision}),v=t.computed(()=>D({height:i.height,width:i.width,horizontal:i.horizontal})),p=t.computed(()=>fe(o.value,i.horizontal));function I(l){return me(l,i.horizontal)}function E(l){return u=>{x(u,l)}}return n({scrollToIndex:d,scrollToOffset:h,measure:y}),(l,u)=>(t.openBlock(),t.createBlock(t.resolveDynamicComponent(e.tag),{ref_key:"container",ref:r,"data-virtual-container":"",role:"list",style:t.normalizeStyle(v.value)},{default:t.withCtx(()=>[e.items.length?(t.openBlock(),t.createElementBlock("div",{key:1,"data-virtual-spacer":"",style:t.normalizeStyle(p.value)},[(t.openBlock(!0),t.createElementBlock(t.Fragment,null,t.renderList(t.unref(s),a=>(t.openBlock(),t.createBlock(t.resolveDynamicComponent(e.itemTag),t.mergeProps({key:a.key,ref_for:!0,ref:E(a.index),role:"listitem","data-index":a.index,"data-key":String(a.key),"aria-setsize":e.items.length,"aria-posinset":a.index+1,style:I(a.start)},{ref_for:!0},e.itemAttrs),{default:t.withCtx(()=>[t.renderSlot(l.$slots,"default",{item:a.item,index:a.index,start:a.start,size:a.size,end:a.end})]),_:2},1040,["data-index","data-key","aria-setsize","aria-posinset","style"]))),128))],4)):t.renderSlot(l.$slots,"empty",{},void 0,void 0,0)]),_:3},8,["style"]))}}),ge=["data-index","data-key"],ve=t.defineComponent({__name:"VirtualGrid",props:{items:{},columnCount:{default:1},estimateRowSize:{type:[Number,Function],default:48},estimateColumnSize:{type:[Number,Function],default:160},height:{},width:{},overscan:{default:2},overscanRows:{},overscanColumns:{},rowGap:{default:0},columnGap:{default:0},getItemKey:{},tag:{default:"div"},itemAttrs:{},revision:{}},setup(e,{expose:n}){const i=e,r=t.ref(null),{virtualCells:s,totalWidth:o,totalHeight:d,scrollToIndex:h,scrollToOffset:y,measureRow:x,measureRowElement:v}=re({items:()=>i.items,columnCount:()=>i.columnCount,estimateRowSize:()=>i.estimateRowSize,estimateColumnSize:()=>i.estimateColumnSize,container:r,overscan:()=>i.overscan,overscanRows:()=>i.overscanRows,overscanColumns:()=>i.overscanColumns,rowGap:()=>i.rowGap,columnGap:()=>i.columnGap,getItemKey:(u,a)=>i.getItemKey?.(u,a)??a,initialRect:()=>({width:B(i.width),height:B(i.height)}),revision:()=>i.revision}),p=t.computed(()=>D({height:i.height,width:i.width,horizontal:!1})),I=t.computed(()=>({position:"relative",width:`${o.value}px`,height:`${d.value}px`}));function E(u){return a=>{v(a,u)}}function l(u,a,f){return{position:"absolute",top:0,left:0,width:`${a}px`,transform:`translate(${u}px, ${f}px)`}}return n({scrollToIndex:h,scrollToOffset:y,measureRow:x}),(u,a)=>(t.openBlock(),t.createBlock(t.resolveDynamicComponent(e.tag),{ref_key:"container",ref:r,"data-virtual-container":"",role:"grid",style:t.normalizeStyle(p.value)},{default:t.withCtx(()=>[e.items.length?(t.openBlock(),t.createElementBlock("div",{key:1,"data-virtual-spacer":"",style:t.normalizeStyle(I.value)},[(t.openBlock(!0),t.createElementBlock(t.Fragment,null,t.renderList(t.unref(s),f=>(t.openBlock(),t.createElementBlock("div",t.mergeProps({key:f.key,ref_for:!0,ref:E(f.row.index),role:"gridcell","data-index":f.index,"data-key":String(f.key),style:l(f.column.start,f.column.size,f.row.start)},{ref_for:!0},e.itemAttrs),[t.renderSlot(u.$slots,"default",{item:f.item,index:f.index,rowIndex:f.row.index,columnIndex:f.column.index,row:f.row,column:f.column})],16,ge))),128))],4)):t.renderSlot(u.$slots,"empty",{},void 0,void 0,0)]),_:3},8,["style"]))}}),Se=["data-index","data-key","aria-rowindex"],ze=t.defineComponent({__name:"VirtualTable",props:{rows:{},columns:{},estimateRowSize:{type:[Number,Function],default:44},height:{},width:{},overscan:{default:5},getRowKey:{},stickyHeader:{type:Boolean,default:!0},tag:{default:"div"},rowAttrs:{},revision:{}},setup(e,{expose:n}){const i=e,r=t.ref(null),s=t.ref(null),o=t.ref(0),{virtualRows:d,columns:h,totalWidth:y,totalHeight:x,scrollToIndex:v,scrollToOffset:p,measure:I,measureElement:E}=se({rows:()=>i.rows,columns:()=>i.columns,estimateRowSize:(m,b)=>{const g=i.estimateRowSize;return typeof g=="number"?g:g(m,b)},container:r,overscan:()=>i.overscan,getRowKey:(m,b)=>i.getRowKey?.(m,b)??b,initialRect:()=>({width:B(i.width),height:B(i.height)}),viewportInset:o,revision:()=>i.revision,itemSize:()=>typeof i.estimateRowSize=="number"?i.estimateRowSize:void 0});t.watch(s,(m,b,g)=>{if(b===m&&!m||!m||!F()||typeof ResizeObserver>"u")return;const R=()=>{o.value=m.getBoundingClientRect().height},L=new ResizeObserver(R);L.observe(m),R(),g(()=>L.disconnect())});const l=t.computed(()=>D({height:i.height,width:i.width,horizontal:!1})),u=t.computed(()=>({minWidth:`${y.value}px`})),a=t.computed(()=>({position:i.stickyHeader?"sticky":"relative",top:i.stickyHeader?"0px":void 0,zIndex:1,display:"flex",width:`${y.value}px`})),f=t.computed(()=>({position:"relative",height:`${x.value}px`,width:`${y.value}px`}));function S(m){return{width:`${m.size}px`,minWidth:`${m.size}px`,flex:"0 0 auto",textAlign:m.align??"left"}}function C(m){return{position:"absolute",top:0,left:0,width:"100%",display:"flex",transform:`translateY(${m}px)`}}function O(m){return b=>{E(b,m)}}function $(m,b,g){return b.accessor?b.accessor(m,g):m&&typeof m=="object"&&b.id in m?m[b.id]:""}return n({scrollToIndex:v,scrollToOffset:p,measure:I}),(m,b)=>(t.openBlock(),t.createBlock(t.resolveDynamicComponent(e.tag),{ref_key:"container",ref:r,"data-virtual-container":"",role:"table",style:t.normalizeStyle(l.value)},{default:t.withCtx(()=>[t.createElementVNode("div",{style:t.normalizeStyle(u.value)},[t.createElementVNode("div",{ref_key:"header",ref:s,role:"row",style:t.normalizeStyle(a.value)},[t.renderSlot(m.$slots,"header",{columns:t.unref(h)},()=>[(t.openBlock(!0),t.createElementBlock(t.Fragment,null,t.renderList(t.unref(h),g=>(t.openBlock(),t.createElementBlock("div",{key:g.id,role:"columnheader",style:t.normalizeStyle(S(g))},t.toDisplayString(g.header),5))),128))])],4),e.rows.length?(t.openBlock(),t.createElementBlock("div",{key:1,"data-virtual-spacer":"",role:"rowgroup",style:t.normalizeStyle(f.value)},[(t.openBlock(!0),t.createElementBlock(t.Fragment,null,t.renderList(t.unref(d),g=>(t.openBlock(),t.createElementBlock("div",t.mergeProps({key:g.key,ref_for:!0,ref:O(g.index),role:"row","data-index":g.index,"data-key":String(g.key),"aria-rowindex":g.index+1,style:C(g.start)},{ref_for:!0},e.rowAttrs),[(t.openBlock(!0),t.createElementBlock(t.Fragment,null,t.renderList(t.unref(h),R=>(t.openBlock(),t.createElementBlock("div",{key:R.id,role:"cell",style:t.normalizeStyle(S(R))},[t.renderSlot(m.$slots,"cell",{row:g.item,column:R,rowIndex:g.index,value:$(g.item,R,g.index)},()=>[t.createTextVNode(t.toDisplayString($(g.item,R,g.index)),1)])],4))),128))],16,Se))),128))],4)):t.renderSlot(m.$slots,"empty",{},void 0,void 0,0)],4)]),_:3},8,["style"]))}});exports.MeasurementCache=Z;exports.VirtualGrid=ve;exports.VirtualList=he;exports.VirtualTable=ze;exports.Virtualizer=ne;exports.clampScrollOffset=G;exports.normalizeSize=K;exports.resolveScrollOffset=te;exports.useVirtualGrid=re;exports.useVirtualList=H;exports.useVirtualTable=se;exports.useVirtualizer=A;
+//# sourceMappingURL=index.js.map