alus-ui 0.1.0

package/dist/components/interactive/sortable/Sortable.svelte.d.ts

@@ -0,0 +1,44 @@
+interface Props<U> {
+    items: U[];
+    getKey?: (item: U, index: number) => string;
+    item: import('svelte').Snippet<[
+        {
+            value: U;
+            index: number;
+            isDragging: boolean;
+            grabbed: boolean;
+            over: boolean;
+            itemAttrs: Record<string, unknown>;
+        }
+    ]>;
+    onReorder?: (items: U[]) => void;
+    orientation?: 'vertical' | 'horizontal';
+    disabled?: boolean;
+    class?: string;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+}
+declare function $$render<T>(): {
+    props: Props<T>;
+    exports: {};
+    bindings: "items";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "items";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Sortable: $$IsomorphicComponent;
+type Sortable<T> = InstanceType<typeof Sortable<T>>;
+export default Sortable;

package/dist/components/interactive/sortable/index.d.ts

@@ -0,0 +1 @@
+export { default as Sortable } from './Sortable.svelte';

package/dist/components/interactive/sortable/index.js

@@ -0,0 +1 @@
+export { default as Sortable } from './Sortable.svelte';

package/dist/components/interactive/split-view/SplitView.svelte

@@ -0,0 +1,98 @@
+<script lang="ts" module>
+	import { getContext, setContext } from 'svelte';
+	import { generateCounterId } from '../../../utils/a11y/id.js';
+
+	const KEY = Symbol('alus-ui:split-view');
+
+	export interface SplitViewContext {
+		orientation: () => 'horizontal' | 'vertical';
+		size: () => number;
+		setSize: (n: number) => void;
+		min: () => number;
+		max: () => number;
+		disabled: () => boolean;
+		dragging: () => boolean;
+		setDragging: (v: boolean) => void;
+		firstPaneId: string;
+		secondPaneId: string;
+	}
+
+	export function getSplitViewContext(): SplitViewContext {
+		const ctx = getContext<SplitViewContext | undefined>(KEY);
+		if (!ctx) throw new Error('SplitView subcomponent must be inside <SplitView>');
+		return ctx;
+	}
+
+	export function setSplitViewContext(ctx: SplitViewContext) {
+		setContext(KEY, ctx);
+	}
+</script>
+
+<script lang="ts">
+	import { labelAttrs } from '../../../utils/a11y/index.js';
+
+	interface Props {
+		children?: import('svelte').Snippet;
+		size?: number;
+		min?: number;
+		max?: number;
+		orientation?: 'horizontal' | 'vertical';
+		disabled?: boolean;
+		class?: string;
+		'aria-label'?: string;
+		'aria-labelledby'?: string;
+		onResize?: (size: number) => void;
+	}
+
+	let {
+		children,
+		size = $bindable(50),
+		min = 10,
+		max = 90,
+		orientation = 'horizontal',
+		disabled = false,
+		class: className = '',
+		'aria-label': ariaLabel,
+		'aria-labelledby': ariaLabelledby,
+		onResize
+	}: Props = $props();
+
+	let dragging = $state(false);
+	const firstPaneId = generateCounterId('split-pane-first');
+	const secondPaneId = generateCounterId('split-pane-second');
+
+	function clamp(v: number): number {
+		return Math.min(max, Math.max(min, v));
+	}
+
+	function setSize(n: number) {
+		const next = clamp(n);
+		if (next !== size) {
+			size = next;
+			onResize?.(next);
+		}
+	}
+
+	setSplitViewContext({
+		orientation: () => orientation,
+		size: () => size,
+		setSize,
+		min: () => min,
+		max: () => max,
+		disabled: () => disabled,
+		dragging: () => dragging,
+		setDragging: (v) => (dragging = v),
+		firstPaneId,
+		secondPaneId
+	});
+</script>
+
+<div
+	class={className}
+	data-orientation={orientation}
+	data-dragging={dragging || undefined}
+	data-disabled={disabled || undefined}
+	{...labelAttrs({ label: ariaLabel, labelledby: ariaLabelledby })}
+>
+	{#if children}{@render children()}{/if}
+</div>

package/dist/components/interactive/split-view/SplitView.svelte.d.ts

@@ -0,0 +1,29 @@
+export interface SplitViewContext {
+    orientation: () => 'horizontal' | 'vertical';
+    size: () => number;
+    setSize: (n: number) => void;
+    min: () => number;
+    max: () => number;
+    disabled: () => boolean;
+    dragging: () => boolean;
+    setDragging: (v: boolean) => void;
+    firstPaneId: string;
+    secondPaneId: string;
+}
+export declare function getSplitViewContext(): SplitViewContext;
+export declare function setSplitViewContext(ctx: SplitViewContext): void;
+interface Props {
+    children?: import('svelte').Snippet;
+    size?: number;
+    min?: number;
+    max?: number;
+    orientation?: 'horizontal' | 'vertical';
+    disabled?: boolean;
+    class?: string;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    onResize?: (size: number) => void;
+}
+declare const SplitView: import("svelte").Component<Props, {}, "size">;
+type SplitView = ReturnType<typeof SplitView>;
+export default SplitView;

package/dist/components/interactive/split-view/SplitViewHandle.svelte

@@ -0,0 +1,123 @@
+<script lang="ts">
+	import type { Attachment } from 'svelte/attachments';
+	import { getSplitViewContext } from './SplitView.svelte';
+	import { labelAttrs, interactiveStateAttrs, widgetAttrs, mergeAttrs } from '../../../utils/a11y/index.js';
+
+	interface Props {
+		class?: string;
+		step?: number;
+		largeStep?: number;
+		'aria-label'?: string;
+		'aria-labelledby'?: string;
+	}
+
+	let {
+		class: className = '',
+		step = 2,
+		largeStep = 10,
+		'aria-label': ariaLabel = 'Resize panes',
+		'aria-labelledby': ariaLabelledby
+	}: Props = $props();
+
+	const ctx = getSplitViewContext();
+	let handleEl: HTMLElement | null = $state(null);
+	let lastCoord = 0;
+	let containerSize = 0;
+
+	function findContainer(node: HTMLElement): HTMLElement {
+		return (node.parentElement as HTMLElement) ?? node;
+	}
+
+	const attach: Attachment<HTMLDivElement> = (node) => {
+		handleEl = node;
+		return () => {
+			handleEl = null;
+		};
+	};
+
+	function onPointerDown(e: PointerEvent) {
+		if (ctx.disabled()) return;
+		e.preventDefault();
+		ctx.setDragging(true);
+		const horiz = ctx.orientation() === 'horizontal';
+		lastCoord = horiz ? e.clientX : e.clientY;
+		const container = handleEl ? findContainer(handleEl) : null;
+		const rect = container?.getBoundingClientRect();
+		containerSize = rect ? (horiz ? rect.width : rect.height) : 0;
+		(e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+	}
+
+	function onPointerMove(e: PointerEvent) {
+		if (!ctx.dragging()) return;
+		if (containerSize <= 0) return;
+		const horiz = ctx.orientation() === 'horizontal';
+		const cur = horiz ? e.clientX : e.clientY;
+		const deltaPx = cur - lastCoord;
+		lastCoord = cur;
+		if (deltaPx === 0) return;
+		const deltaPct = (deltaPx / containerSize) * 100;
+		ctx.setSize(ctx.size() + deltaPct);
+	}
+
+	function onPointerUp(e: PointerEvent) {
+		if (!ctx.dragging()) return;
+		ctx.setDragging(false);
+		try {
+			(e.currentTarget as HTMLElement).releasePointerCapture(e.pointerId);
+		} catch {
+			/* noop */
+		}
+	}
+
+	function onKeydown(e: KeyboardEvent) {
+		if (ctx.disabled()) return;
+		const horiz = ctx.orientation() === 'horizontal';
+		const incKey = horiz ? 'ArrowRight' : 'ArrowDown';
+		const decKey = horiz ? 'ArrowLeft' : 'ArrowUp';
+		let delta = 0;
+		if (e.key === incKey) delta = step;
+		else if (e.key === decKey) delta = -step;
+		else if (e.key === 'PageDown') delta = largeStep;
+		else if (e.key === 'PageUp') delta = -largeStep;
+		else if (e.key === 'Home') {
+			e.preventDefault();
+			ctx.setSize(ctx.min());
+			return;
+		} else if (e.key === 'End') {
+			e.preventDefault();
+			ctx.setSize(ctx.max());
+			return;
+		} else {
+			return;
+		}
+		e.preventDefault();
+		ctx.setSize(ctx.size() + delta);
+	}
+</script>
+
+<!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+<!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+<div
+	{@attach attach}
+	role="separator"
+	tabindex={ctx.disabled() ? -1 : 0}
+	data-dragging={ctx.dragging() || undefined}
+	data-orientation={ctx.orientation()}
+	class={className}
+	onpointerdown={onPointerDown}
+	onpointermove={onPointerMove}
+	onpointerup={onPointerUp}
+	onpointercancel={onPointerUp}
+	onkeydown={onKeydown}
+	{...mergeAttrs(
+		labelAttrs({ label: ariaLabel, labelledby: ariaLabelledby }),
+		interactiveStateAttrs({ disabled: ctx.disabled() }),
+		widgetAttrs({
+			orientation: ctx.orientation() === 'horizontal' ? 'vertical' : 'horizontal',
+			valuenow: Math.round(ctx.size()),
+			valuemin: ctx.min(),
+			valuemax: ctx.max(),
+			controls: `${ctx.firstPaneId} ${ctx.secondPaneId}`
+		})
+	)}
+></div>

package/dist/components/interactive/split-view/SplitViewHandle.svelte.d.ts

@@ -0,0 +1,10 @@
+interface Props {
+    class?: string;
+    step?: number;
+    largeStep?: number;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+}
+declare const SplitViewHandle: import("svelte").Component<Props, {}, "">;
+type SplitViewHandle = ReturnType<typeof SplitViewHandle>;
+export default SplitViewHandle;

package/dist/components/interactive/split-view/SplitViewPane.svelte

@@ -0,0 +1,43 @@
+<script lang="ts">
+	import { getSplitViewContext } from './SplitView.svelte';
+	import { labelAttrs } from '../../../utils/a11y/index.js';
+
+	interface Props {
+		children?: import('svelte').Snippet;
+		side: 'first' | 'second';
+		class?: string;
+		'aria-label'?: string;
+		'aria-labelledby'?: string;
+	}
+
+	let {
+		children,
+		side,
+		class: className = '',
+		'aria-label': ariaLabel,
+		'aria-labelledby': ariaLabelledby
+	}: Props = $props();
+
+	const ctx = getSplitViewContext();
+
+	const paneStyle = $derived.by(() => {
+		const horiz = ctx.orientation() === 'horizontal';
+		const size = ctx.size();
+		const dim = horiz ? 'width' : 'height';
+		const value = side === 'first' ? `${size}%` : `${100 - size}%`;
+		return `${dim}:${value};flex:0 0 ${value};`;
+	});
+
+	const paneId = $derived(side === 'first' ? ctx.firstPaneId : ctx.secondPaneId);
+</script>
+
+<div
+	id={paneId}
+	role="group"
+	data-side={side}
+	class={className}
+	style={paneStyle}
+	{...labelAttrs({ label: ariaLabel, labelledby: ariaLabelledby })}
+>
+	{#if children}{@render children()}{/if}
+</div>

package/dist/components/interactive/split-view/SplitViewPane.svelte.d.ts

@@ -0,0 +1,10 @@
+interface Props {
+    children?: import('svelte').Snippet;
+    side: 'first' | 'second';
+    class?: string;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+}
+declare const SplitViewPane: import("svelte").Component<Props, {}, "">;
+type SplitViewPane = ReturnType<typeof SplitViewPane>;
+export default SplitViewPane;

package/dist/components/interactive/split-view/index.d.ts

@@ -0,0 +1,5 @@
+export { default as SplitView } from './SplitView.svelte';
+export { default as SplitViewPane } from './SplitViewPane.svelte';
+export { default as SplitViewHandle } from './SplitViewHandle.svelte';
+export { getSplitViewContext, setSplitViewContext } from './SplitView.svelte';
+export type { SplitViewContext } from './SplitView.svelte';

package/dist/components/interactive/split-view/index.js

@@ -0,0 +1,4 @@
+export { default as SplitView } from './SplitView.svelte';
+export { default as SplitViewPane } from './SplitViewPane.svelte';
+export { default as SplitViewHandle } from './SplitViewHandle.svelte';
+export { getSplitViewContext, setSplitViewContext } from './SplitView.svelte';

package/dist/components/interactive/swipeable/Swipeable.svelte

@@ -0,0 +1,147 @@
+<script lang="ts">
+	export type SwipeDirection = 'left' | 'right' | 'up' | 'down';
+
+	interface SwipeInfo {
+		dx: number;
+		dy: number;
+	}
+
+	interface SwipeEndInfo extends SwipeInfo {
+		direction: SwipeDirection | null;
+		duration: number;
+	}
+
+	interface Props {
+		children?: import('svelte').Snippet;
+		class?: string;
+		threshold?: number;
+		velocityThreshold?: number;
+		disabled?: boolean;
+		preventScroll?: boolean;
+		'aria-label'?: string;
+		onSwipe?: (direction: SwipeDirection) => void;
+		onSwipeStart?: (e: PointerEvent) => void;
+		onSwipeMove?: (info: SwipeInfo) => void;
+		onSwipeEnd?: (info: SwipeEndInfo) => void;
+		onSwipeLeft?: () => void;
+		onSwipeRight?: () => void;
+		onSwipeUp?: () => void;
+		onSwipeDown?: () => void;
+	}
+
+	let {
+		children,
+		class: className = '',
+		threshold = 50,
+		velocityThreshold = 0.3,
+		disabled = false,
+		preventScroll = false,
+		'aria-label': ariaLabel = 'Swipeable region',
+		onSwipe,
+		onSwipeStart,
+		onSwipeMove,
+		onSwipeEnd,
+		onSwipeLeft,
+		onSwipeRight,
+		onSwipeUp,
+		onSwipeDown
+	}: Props = $props();
+
+	let startX = 0;
+	let startY = 0;
+	let startTime = 0;
+	let activeId: number | null = null;
+	let tracking = $state(false);
+
+	function onPointerDown(e: PointerEvent) {
+		if (disabled || !e.isPrimary || activeId != null) return;
+		tracking = true;
+		activeId = e.pointerId;
+		startX = e.clientX;
+		startY = e.clientY;
+		startTime = performance.now();
+		(e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+		onSwipeStart?.(e);
+	}
+
+	function onPointerMove(e: PointerEvent) {
+		if (!tracking || e.pointerId !== activeId) return;
+		if (preventScroll) e.preventDefault();
+		onSwipeMove?.({ dx: e.clientX - startX, dy: e.clientY - startY });
+	}
+
+	function finish(e: PointerEvent, cancelled: boolean) {
+		if (!tracking || e.pointerId !== activeId) return;
+		const dx = e.clientX - startX;
+		const dy = e.clientY - startY;
+		const duration = Math.max(1, performance.now() - startTime);
+		const adx = Math.abs(dx);
+		const ady = Math.abs(dy);
+		let direction: SwipeDirection | null = null;
+		if (!cancelled) {
+			const passDistance = Math.max(adx, ady) >= threshold;
+			const velocity = Math.max(adx, ady) / duration;
+			const passVelocity = velocity >= velocityThreshold;
+			if (passDistance || passVelocity) {
+				if (adx > ady) direction = dx > 0 ? 'right' : 'left';
+				else direction = dy > 0 ? 'down' : 'up';
+			}
+		}
+		tracking = false;
+		activeId = null;
+		try {
+			(e.currentTarget as HTMLElement).releasePointerCapture(e.pointerId);
+		} catch {
+			/* noop */
+		}
+		onSwipeEnd?.({ dx, dy, direction, duration });
+		if (direction) {
+			onSwipe?.(direction);
+			if (direction === 'left') onSwipeLeft?.();
+			else if (direction === 'right') onSwipeRight?.();
+			else if (direction === 'up') onSwipeUp?.();
+			else if (direction === 'down') onSwipeDown?.();
+		}
+	}
+
+	function onPointerUp(e: PointerEvent) {
+		finish(e, false);
+	}
+	function onPointerCancel(e: PointerEvent) {
+		finish(e, true);
+	}
+
+	function onKeydown(e: KeyboardEvent) {
+		if (disabled) return;
+		let dir: SwipeDirection | null = null;
+		if (e.key === 'ArrowLeft') dir = 'left';
+		else if (e.key === 'ArrowRight') dir = 'right';
+		else if (e.key === 'ArrowUp') dir = 'up';
+		else if (e.key === 'ArrowDown') dir = 'down';
+		if (!dir) return;
+		e.preventDefault();
+		onSwipe?.(dir);
+		if (dir === 'left') onSwipeLeft?.();
+		else if (dir === 'right') onSwipeRight?.();
+		else if (dir === 'up') onSwipeUp?.();
+		else if (dir === 'down') onSwipeDown?.();
+	}
+</script>
+
+<!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+<!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+<div
+	class={className}
+	role="region"
+	aria-label={ariaLabel}
+	tabindex={disabled ? -1 : 0}
+	data-tracking={tracking || undefined}
+	data-disabled={disabled || undefined}
+	onpointerdown={onPointerDown}
+	onpointermove={onPointerMove}
+	onpointerup={onPointerUp}
+	onpointercancel={onPointerCancel}
+	onkeydown={onKeydown}
+>
+	{#if children}{@render children()}{/if}
+</div>

package/dist/components/interactive/swipeable/Swipeable.svelte.d.ts

@@ -0,0 +1,29 @@
+export type SwipeDirection = 'left' | 'right' | 'up' | 'down';
+interface SwipeInfo {
+    dx: number;
+    dy: number;
+}
+interface SwipeEndInfo extends SwipeInfo {
+    direction: SwipeDirection | null;
+    duration: number;
+}
+interface Props {
+    children?: import('svelte').Snippet;
+    class?: string;
+    threshold?: number;
+    velocityThreshold?: number;
+    disabled?: boolean;
+    preventScroll?: boolean;
+    'aria-label'?: string;
+    onSwipe?: (direction: SwipeDirection) => void;
+    onSwipeStart?: (e: PointerEvent) => void;
+    onSwipeMove?: (info: SwipeInfo) => void;
+    onSwipeEnd?: (info: SwipeEndInfo) => void;
+    onSwipeLeft?: () => void;
+    onSwipeRight?: () => void;
+    onSwipeUp?: () => void;
+    onSwipeDown?: () => void;
+}
+declare const Swipeable: import("svelte").Component<Props, {}, "">;
+type Swipeable = ReturnType<typeof Swipeable>;
+export default Swipeable;

package/dist/components/interactive/swipeable/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Swipeable } from './Swipeable.svelte';
+export type { SwipeDirection } from './Swipeable.svelte';

package/dist/components/interactive/swipeable/index.js

@@ -0,0 +1 @@
+export { default as Swipeable } from './Swipeable.svelte';

package/dist/components/interactive/virtual-list/VirtualList.svelte

@@ -0,0 +1,84 @@
+<script lang="ts" generics="T">
+	import type { Attachment } from 'svelte/attachments';
+
+	interface Props {
+		items: T[];
+		itemHeight: number;
+		overscan?: number;
+		class?: string;
+		innerClass?: string;
+		itemClass?: string;
+		style?: string;
+		'aria-label'?: string;
+		item: import('svelte').Snippet<[{ item: T; index: number; style: string }]>;
+	}
+
+	let {
+		items,
+		itemHeight,
+		overscan = 4,
+		class: className = '',
+		innerClass = '',
+		itemClass = '',
+		style,
+		'aria-label': ariaLabel,
+		item
+	}: Props = $props();
+
+	let scrollTop = $state(0);
+	let viewportHeight = $state(0);
+
+	const totalHeight = $derived(items.length * itemHeight);
+
+	const range = $derived.by(() => {
+		if (!viewportHeight || itemHeight <= 0) return { start: 0, end: Math.min(items.length, 20) };
+		const visible = Math.ceil(viewportHeight / itemHeight);
+		const start = Math.max(0, Math.floor(scrollTop / itemHeight) - overscan);
+		const end = Math.min(items.length, start + visible + overscan * 2);
+		return { start, end };
+	});
+
+	const slice = $derived(items.slice(range.start, range.end));
+
+	const containerRef: Attachment<HTMLDivElement> = (node) => {
+		const onScroll = () => {
+			scrollTop = node.scrollTop;
+		};
+		const ro = new ResizeObserver(() => {
+			viewportHeight = node.clientHeight;
+		});
+		viewportHeight = node.clientHeight;
+		node.addEventListener('scroll', onScroll, { passive: true });
+		ro.observe(node);
+		return () => {
+			node.removeEventListener('scroll', onScroll);
+			ro.disconnect();
+		};
+	};
+
+	function rowStyle(i: number) {
+		return `position:absolute; top:${(range.start + i) * itemHeight}px; left:0; right:0; height:${itemHeight}px;`;
+	}
+</script>
+
+<div
+	class={className}
+	style={`overflow:auto; position:relative; ${style ?? ''}`}
+	role="list"
+	aria-label={ariaLabel}
+	{@attach containerRef}
+>
+	<div class={innerClass} style={`position:relative; height:${totalHeight}px;`}>
+		{#each slice as it, i (range.start + i)}
+			<div
+				role="listitem"
+				aria-setsize={items.length}
+				aria-posinset={range.start + i + 1}
+				class={itemClass}
+				style={rowStyle(i)}
+			>
+				{@render item({ item: it, index: range.start + i, style: rowStyle(i) })}
+			</div>
+		{/each}
+	</div>
+</div>

package/dist/components/interactive/virtual-list/VirtualList.svelte.d.ts

@@ -0,0 +1,38 @@
+declare function $$render<T>(): {
+    props: {
+        items: T[];
+        itemHeight: number;
+        overscan?: number;
+        class?: string;
+        innerClass?: string;
+        itemClass?: string;
+        style?: string;
+        'aria-label'?: string;
+        item: import("svelte").Snippet<[{
+            item: T;
+            index: number;
+            style: string;
+        }]>;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const VirtualList: $$IsomorphicComponent;
+type VirtualList<T> = InstanceType<typeof VirtualList<T>>;
+export default VirtualList;