@cherrystudio/file-preview 0.0.0-stage → 0.1.0

package/dist/SpreadsheetFilePreview-DJdoyeis.js

@@ -0,0 +1,3217 @@
+import "./documentAnchor-J7GGLU15.js";
+import { r as readPreviewDocument, t as PreviewError } from "./source-Rx3etU3y.js";
+import { F as cn, I as LoaderCircle, N as EmptyState, i as FilePreviewLayout, o as usePreviewHost, r as FilePreviewToolbarButton, s as usePreviewLogger, t as useTranslation, z as cva } from "./useTranslation-DMhY277o.js";
+import { n as normalizeSelectionText, r as CircleAlert, t as createPreviewSelection } from "./selection-CQPD5a6C.js";
+import { n as ZoomIn, t as ZoomOut } from "./zoom-out-DLOQGt1e.js";
+import { t as FilePreviewTooLarge } from "./FilePreviewTooLarge-DkHa6toZ.js";
+import * as React$1 from "react";
+import React, { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { flushSync } from "react-dom";
+typeof window !== "undefined" && window.document && window.document.createElement;
+function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+	return function handleEvent(event) {
+		originalEventHandler?.(event);
+		if (checkForDefaultPrevented === false || !event.defaultPrevented) return ourEventHandler?.(event);
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-context@1.1.2_@types+react@19.2.7_react@19.2.3/node_modules/@radix-ui/react-context/dist/index.mjs
+function createContextScope(scopeName, createContextScopeDeps = []) {
+	let defaultContexts = [];
+	function createContext3(rootComponentName, defaultContext) {
+		const BaseContext = React$1.createContext(defaultContext);
+		const index = defaultContexts.length;
+		defaultContexts = [...defaultContexts, defaultContext];
+		const Provider = (props) => {
+			const { scope, children, ...context } = props;
+			const Context = scope?.[scopeName]?.[index] || BaseContext;
+			const value = React$1.useMemo(() => context, Object.values(context));
+			return /* @__PURE__ */ jsx(Context.Provider, {
+				value,
+				children
+			});
+		};
+		Provider.displayName = rootComponentName + "Provider";
+		function useContext2(consumerName, scope) {
+			const Context = scope?.[scopeName]?.[index] || BaseContext;
+			const context = React$1.useContext(Context);
+			if (context) return context;
+			if (defaultContext !== void 0) return defaultContext;
+			throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+		}
+		return [Provider, useContext2];
+	}
+	const createScope = () => {
+		const scopeContexts = defaultContexts.map((defaultContext) => {
+			return React$1.createContext(defaultContext);
+		});
+		return function useScope(scope) {
+			const contexts = scope?.[scopeName] || scopeContexts;
+			return React$1.useMemo(() => ({ [`__scope${scopeName}`]: {
+				...scope,
+				[scopeName]: contexts
+			} }), [scope, contexts]);
+		};
+	};
+	createScope.scopeName = scopeName;
+	return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];
+}
+function composeContextScopes(...scopes) {
+	const baseScope = scopes[0];
+	if (scopes.length === 1) return baseScope;
+	const createScope = () => {
+		const scopeHooks = scopes.map((createScope2) => ({
+			useScope: createScope2(),
+			scopeName: createScope2.scopeName
+		}));
+		return function useComposedScopes(overrideScopes) {
+			const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
+				const currentScope = useScope(overrideScopes)[`__scope${scopeName}`];
+				return {
+					...nextScopes2,
+					...currentScope
+				};
+			}, {});
+			return React$1.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
+		};
+	};
+	createScope.scopeName = baseScope.scopeName;
+	return createScope;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-compose-refs@1.1.2_@types+react@19.2.7_react@19.2.3/node_modules/@radix-ui/react-compose-refs/dist/index.mjs
+function setRef(ref, value) {
+	if (typeof ref === "function") return ref(value);
+	else if (ref !== null && ref !== void 0) ref.current = value;
+}
+function composeRefs(...refs) {
+	return (node) => {
+		let hasCleanup = false;
+		const cleanups = refs.map((ref) => {
+			const cleanup = setRef(ref, node);
+			if (!hasCleanup && typeof cleanup == "function") hasCleanup = true;
+			return cleanup;
+		});
+		if (hasCleanup) return () => {
+			for (let i = 0; i < cleanups.length; i++) {
+				const cleanup = cleanups[i];
+				if (typeof cleanup == "function") cleanup();
+				else setRef(refs[i], null);
+			}
+		};
+	};
+}
+function useComposedRefs(...refs) {
+	return React$1.useCallback(composeRefs(...refs), refs);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-slot@1.2.3_@types+react@19.2.7_react@19.2.3/node_modules/@radix-ui/react-slot/dist/index.mjs
+// @__NO_SIDE_EFFECTS__
+function createSlot(ownerName) {
+	const SlotClone = /* @__PURE__ */ createSlotClone(ownerName);
+	const Slot2 = React$1.forwardRef((props, forwardedRef) => {
+		const { children, ...slotProps } = props;
+		const childrenArray = React$1.Children.toArray(children);
+		const slottable = childrenArray.find(isSlottable);
+		if (slottable) {
+			const newElement = slottable.props.children;
+			const newChildren = childrenArray.map((child) => {
+				if (child === slottable) {
+					if (React$1.Children.count(newElement) > 1) return React$1.Children.only(null);
+					return React$1.isValidElement(newElement) ? newElement.props.children : null;
+				} else return child;
+			});
+			return /* @__PURE__ */ jsx(SlotClone, {
+				...slotProps,
+				ref: forwardedRef,
+				children: React$1.isValidElement(newElement) ? React$1.cloneElement(newElement, void 0, newChildren) : null
+			});
+		}
+		return /* @__PURE__ */ jsx(SlotClone, {
+			...slotProps,
+			ref: forwardedRef,
+			children
+		});
+	});
+	Slot2.displayName = `${ownerName}.Slot`;
+	return Slot2;
+}
+// @__NO_SIDE_EFFECTS__
+function createSlotClone(ownerName) {
+	const SlotClone = React$1.forwardRef((props, forwardedRef) => {
+		const { children, ...slotProps } = props;
+		if (React$1.isValidElement(children)) {
+			const childrenRef = getElementRef$1(children);
+			const props2 = mergeProps(slotProps, children.props);
+			if (children.type !== React$1.Fragment) props2.ref = forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef;
+			return React$1.cloneElement(children, props2);
+		}
+		return React$1.Children.count(children) > 1 ? React$1.Children.only(null) : null;
+	});
+	SlotClone.displayName = `${ownerName}.SlotClone`;
+	return SlotClone;
+}
+var SLOTTABLE_IDENTIFIER = Symbol("radix.slottable");
+function isSlottable(child) {
+	return React$1.isValidElement(child) && typeof child.type === "function" && "__radixId" in child.type && child.type.__radixId === SLOTTABLE_IDENTIFIER;
+}
+function mergeProps(slotProps, childProps) {
+	const overrideProps = { ...childProps };
+	for (const propName in childProps) {
+		const slotPropValue = slotProps[propName];
+		const childPropValue = childProps[propName];
+		if (/^on[A-Z]/.test(propName)) {
+			if (slotPropValue && childPropValue) overrideProps[propName] = (...args) => {
+				const result = childPropValue(...args);
+				slotPropValue(...args);
+				return result;
+			};
+			else if (slotPropValue) overrideProps[propName] = slotPropValue;
+		} else if (propName === "style") overrideProps[propName] = {
+			...slotPropValue,
+			...childPropValue
+		};
+		else if (propName === "className") overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+	}
+	return {
+		...slotProps,
+		...overrideProps
+	};
+}
+function getElementRef$1(element) {
+	let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+	let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+	if (mayWarn) return element.ref;
+	getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+	mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+	if (mayWarn) return element.props.ref;
+	return element.props.ref || element.ref;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-collection@1.1.7_@types+react-dom@19.2.3_@types+react@19.2.7__@types+re_51f38897cc3aa0a11933866657bdcfb1/node_modules/@radix-ui/react-collection/dist/index.mjs
+function createCollection(name) {
+	const PROVIDER_NAME = name + "CollectionProvider";
+	const [createCollectionContext, createCollectionScope] = createContextScope(PROVIDER_NAME);
+	const [CollectionProviderImpl, useCollectionContext] = createCollectionContext(PROVIDER_NAME, {
+		collectionRef: { current: null },
+		itemMap: /* @__PURE__ */ new Map()
+	});
+	const CollectionProvider = (props) => {
+		const { scope, children } = props;
+		const ref = React.useRef(null);
+		const itemMap = React.useRef(/* @__PURE__ */ new Map()).current;
+		return /* @__PURE__ */ jsx(CollectionProviderImpl, {
+			scope,
+			itemMap,
+			collectionRef: ref,
+			children
+		});
+	};
+	CollectionProvider.displayName = PROVIDER_NAME;
+	const COLLECTION_SLOT_NAME = name + "CollectionSlot";
+	const CollectionSlotImpl = /* @__PURE__ */ createSlot(COLLECTION_SLOT_NAME);
+	const CollectionSlot = React.forwardRef((props, forwardedRef) => {
+		const { scope, children } = props;
+		const composedRefs = useComposedRefs(forwardedRef, useCollectionContext(COLLECTION_SLOT_NAME, scope).collectionRef);
+		return /* @__PURE__ */ jsx(CollectionSlotImpl, {
+			ref: composedRefs,
+			children
+		});
+	});
+	CollectionSlot.displayName = COLLECTION_SLOT_NAME;
+	const ITEM_SLOT_NAME = name + "CollectionItemSlot";
+	const ITEM_DATA_ATTR = "data-radix-collection-item";
+	const CollectionItemSlotImpl = /* @__PURE__ */ createSlot(ITEM_SLOT_NAME);
+	const CollectionItemSlot = React.forwardRef((props, forwardedRef) => {
+		const { scope, children, ...itemData } = props;
+		const ref = React.useRef(null);
+		const composedRefs = useComposedRefs(forwardedRef, ref);
+		const context = useCollectionContext(ITEM_SLOT_NAME, scope);
+		React.useEffect(() => {
+			context.itemMap.set(ref, {
+				ref,
+				...itemData
+			});
+			return () => void context.itemMap.delete(ref);
+		});
+		return /* @__PURE__ */ jsx(CollectionItemSlotImpl, {
+			[ITEM_DATA_ATTR]: "",
+			ref: composedRefs,
+			children
+		});
+	});
+	CollectionItemSlot.displayName = ITEM_SLOT_NAME;
+	function useCollection(scope) {
+		const context = useCollectionContext(name + "CollectionConsumer", scope);
+		return React.useCallback(() => {
+			const collectionNode = context.collectionRef.current;
+			if (!collectionNode) return [];
+			const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));
+			return Array.from(context.itemMap.values()).sort((a, b) => orderedNodes.indexOf(a.ref.current) - orderedNodes.indexOf(b.ref.current));
+		}, [context.collectionRef, context.itemMap]);
+	}
+	return [
+		{
+			Provider: CollectionProvider,
+			Slot: CollectionSlot,
+			ItemSlot: CollectionItemSlot
+		},
+		useCollection,
+		createCollectionScope
+	];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-use-layout-effect@1.1.1_@types+react@19.2.7_react@19.2.3/node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs
+var useLayoutEffect2 = globalThis?.document ? React$1.useLayoutEffect : () => {};
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-id@1.1.1_@types+react@19.2.7_react@19.2.3/node_modules/@radix-ui/react-id/dist/index.mjs
+var useReactId = React$1[" useId ".trim().toString()] || (() => void 0);
+var count = 0;
+function useId$1(deterministicId) {
+	const [id, setId] = React$1.useState(useReactId());
+	useLayoutEffect2(() => {
+		if (!deterministicId) setId((reactId) => reactId ?? String(count++));
+	}, [deterministicId]);
+	return deterministicId || (id ? `radix-${id}` : "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-primitive@2.1.3_@types+react-dom@19.2.3_@types+react@19.2.7__@types+rea_5f3d28fea11cf58eed3830d0189b6e2d/node_modules/@radix-ui/react-primitive/dist/index.mjs
+var Primitive = [
+	"a",
+	"button",
+	"div",
+	"form",
+	"h2",
+	"h3",
+	"img",
+	"input",
+	"label",
+	"li",
+	"nav",
+	"ol",
+	"p",
+	"select",
+	"span",
+	"svg",
+	"ul"
+].reduce((primitive, node) => {
+	const Slot = /* @__PURE__ */ createSlot(`Primitive.${node}`);
+	const Node = React$1.forwardRef((props, forwardedRef) => {
+		const { asChild, ...primitiveProps } = props;
+		const Comp = asChild ? Slot : node;
+		if (typeof window !== "undefined") window[Symbol.for("radix-ui")] = true;
+		return /* @__PURE__ */ jsx(Comp, {
+			...primitiveProps,
+			ref: forwardedRef
+		});
+	});
+	Node.displayName = `Primitive.${node}`;
+	return {
+		...primitive,
+		[node]: Node
+	};
+}, {});
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-use-callback-ref@1.1.1_@types+react@19.2.7_react@19.2.3/node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs
+function useCallbackRef(callback) {
+	const callbackRef = React$1.useRef(callback);
+	React$1.useEffect(() => {
+		callbackRef.current = callback;
+	});
+	return React$1.useMemo(() => (...args) => callbackRef.current?.(...args), []);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-use-controllable-state@1.2.2_@types+react@19.2.7_react@19.2.3/node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
+var useInsertionEffect = React$1[" useInsertionEffect ".trim().toString()] || useLayoutEffect2;
+function useControllableState({ prop, defaultProp, onChange = () => {}, caller }) {
+	const [uncontrolledProp, setUncontrolledProp, onChangeRef] = useUncontrolledState({
+		defaultProp,
+		onChange
+	});
+	const isControlled = prop !== void 0;
+	const value = isControlled ? prop : uncontrolledProp;
+	{
+		const isControlledRef = React$1.useRef(prop !== void 0);
+		React$1.useEffect(() => {
+			const wasControlled = isControlledRef.current;
+			if (wasControlled !== isControlled) console.warn(`${caller} is changing from ${wasControlled ? "controlled" : "uncontrolled"} to ${isControlled ? "controlled" : "uncontrolled"}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`);
+			isControlledRef.current = isControlled;
+		}, [isControlled, caller]);
+	}
+	return [value, React$1.useCallback((nextValue) => {
+		if (isControlled) {
+			const value2 = isFunction(nextValue) ? nextValue(prop) : nextValue;
+			if (value2 !== prop) onChangeRef.current?.(value2);
+		} else setUncontrolledProp(nextValue);
+	}, [
+		isControlled,
+		prop,
+		setUncontrolledProp,
+		onChangeRef
+	])];
+}
+function useUncontrolledState({ defaultProp, onChange }) {
+	const [value, setValue] = React$1.useState(defaultProp);
+	const prevValueRef = React$1.useRef(value);
+	const onChangeRef = React$1.useRef(onChange);
+	useInsertionEffect(() => {
+		onChangeRef.current = onChange;
+	}, [onChange]);
+	React$1.useEffect(() => {
+		if (prevValueRef.current !== value) {
+			onChangeRef.current?.(value);
+			prevValueRef.current = value;
+		}
+	}, [value, prevValueRef]);
+	return [
+		value,
+		setValue,
+		onChangeRef
+	];
+}
+function isFunction(value) {
+	return typeof value === "function";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-direction@1.1.1_@types+react@19.2.7_react@19.2.3/node_modules/@radix-ui/react-direction/dist/index.mjs
+var DirectionContext = React$1.createContext(void 0);
+function useDirection(localDir) {
+	const globalDir = React$1.useContext(DirectionContext);
+	return localDir || globalDir || "ltr";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-roving-focus@1.1.11_@types+react-dom@19.2.3_@types+react@19.2.7__@types_15baa560c953bc49315682e94c801f68/node_modules/@radix-ui/react-roving-focus/dist/index.mjs
+var ENTRY_FOCUS = "rovingFocusGroup.onEntryFocus";
+var EVENT_OPTIONS = {
+	bubbles: false,
+	cancelable: true
+};
+var GROUP_NAME = "RovingFocusGroup";
+var [Collection, useCollection, createCollectionScope] = createCollection(GROUP_NAME);
+var [createRovingFocusGroupContext, createRovingFocusGroupScope] = createContextScope(GROUP_NAME, [createCollectionScope]);
+var [RovingFocusProvider, useRovingFocusContext] = createRovingFocusGroupContext(GROUP_NAME);
+var RovingFocusGroup = React$1.forwardRef((props, forwardedRef) => {
+	return /* @__PURE__ */ jsx(Collection.Provider, {
+		scope: props.__scopeRovingFocusGroup,
+		children: /* @__PURE__ */ jsx(Collection.Slot, {
+			scope: props.__scopeRovingFocusGroup,
+			children: /* @__PURE__ */ jsx(RovingFocusGroupImpl, {
+				...props,
+				ref: forwardedRef
+			})
+		})
+	});
+});
+RovingFocusGroup.displayName = GROUP_NAME;
+var RovingFocusGroupImpl = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeRovingFocusGroup, orientation, loop = false, dir, currentTabStopId: currentTabStopIdProp, defaultCurrentTabStopId, onCurrentTabStopIdChange, onEntryFocus, preventScrollOnEntryFocus = false, ...groupProps } = props;
+	const ref = React$1.useRef(null);
+	const composedRefs = useComposedRefs(forwardedRef, ref);
+	const direction = useDirection(dir);
+	const [currentTabStopId, setCurrentTabStopId] = useControllableState({
+		prop: currentTabStopIdProp,
+		defaultProp: defaultCurrentTabStopId ?? null,
+		onChange: onCurrentTabStopIdChange,
+		caller: GROUP_NAME
+	});
+	const [isTabbingBackOut, setIsTabbingBackOut] = React$1.useState(false);
+	const handleEntryFocus = useCallbackRef(onEntryFocus);
+	const getItems = useCollection(__scopeRovingFocusGroup);
+	const isClickFocusRef = React$1.useRef(false);
+	const [focusableItemsCount, setFocusableItemsCount] = React$1.useState(0);
+	React$1.useEffect(() => {
+		const node = ref.current;
+		if (node) {
+			node.addEventListener(ENTRY_FOCUS, handleEntryFocus);
+			return () => node.removeEventListener(ENTRY_FOCUS, handleEntryFocus);
+		}
+	}, [handleEntryFocus]);
+	return /* @__PURE__ */ jsx(RovingFocusProvider, {
+		scope: __scopeRovingFocusGroup,
+		orientation,
+		dir: direction,
+		loop,
+		currentTabStopId,
+		onItemFocus: React$1.useCallback((tabStopId) => setCurrentTabStopId(tabStopId), [setCurrentTabStopId]),
+		onItemShiftTab: React$1.useCallback(() => setIsTabbingBackOut(true), []),
+		onFocusableItemAdd: React$1.useCallback(() => setFocusableItemsCount((prevCount) => prevCount + 1), []),
+		onFocusableItemRemove: React$1.useCallback(() => setFocusableItemsCount((prevCount) => prevCount - 1), []),
+		children: /* @__PURE__ */ jsx(Primitive.div, {
+			tabIndex: isTabbingBackOut || focusableItemsCount === 0 ? -1 : 0,
+			"data-orientation": orientation,
+			...groupProps,
+			ref: composedRefs,
+			style: {
+				outline: "none",
+				...props.style
+			},
+			onMouseDown: composeEventHandlers(props.onMouseDown, () => {
+				isClickFocusRef.current = true;
+			}),
+			onFocus: composeEventHandlers(props.onFocus, (event) => {
+				const isKeyboardFocus = !isClickFocusRef.current;
+				if (event.target === event.currentTarget && isKeyboardFocus && !isTabbingBackOut) {
+					const entryFocusEvent = new CustomEvent(ENTRY_FOCUS, EVENT_OPTIONS);
+					event.currentTarget.dispatchEvent(entryFocusEvent);
+					if (!entryFocusEvent.defaultPrevented) {
+						const items = getItems().filter((item) => item.focusable);
+						focusFirst([
+							items.find((item) => item.active),
+							items.find((item) => item.id === currentTabStopId),
+							...items
+						].filter(Boolean).map((item) => item.ref.current), preventScrollOnEntryFocus);
+					}
+				}
+				isClickFocusRef.current = false;
+			}),
+			onBlur: composeEventHandlers(props.onBlur, () => setIsTabbingBackOut(false))
+		})
+	});
+});
+var ITEM_NAME = "RovingFocusGroupItem";
+var RovingFocusGroupItem = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeRovingFocusGroup, focusable = true, active = false, tabStopId, children, ...itemProps } = props;
+	const autoId = useId$1();
+	const id = tabStopId || autoId;
+	const context = useRovingFocusContext(ITEM_NAME, __scopeRovingFocusGroup);
+	const isCurrentTabStop = context.currentTabStopId === id;
+	const getItems = useCollection(__scopeRovingFocusGroup);
+	const { onFocusableItemAdd, onFocusableItemRemove, currentTabStopId } = context;
+	React$1.useEffect(() => {
+		if (focusable) {
+			onFocusableItemAdd();
+			return () => onFocusableItemRemove();
+		}
+	}, [
+		focusable,
+		onFocusableItemAdd,
+		onFocusableItemRemove
+	]);
+	return /* @__PURE__ */ jsx(Collection.ItemSlot, {
+		scope: __scopeRovingFocusGroup,
+		id,
+		focusable,
+		active,
+		children: /* @__PURE__ */ jsx(Primitive.span, {
+			tabIndex: isCurrentTabStop ? 0 : -1,
+			"data-orientation": context.orientation,
+			...itemProps,
+			ref: forwardedRef,
+			onMouseDown: composeEventHandlers(props.onMouseDown, (event) => {
+				if (!focusable) event.preventDefault();
+				else context.onItemFocus(id);
+			}),
+			onFocus: composeEventHandlers(props.onFocus, () => context.onItemFocus(id)),
+			onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
+				if (event.key === "Tab" && event.shiftKey) {
+					context.onItemShiftTab();
+					return;
+				}
+				if (event.target !== event.currentTarget) return;
+				const focusIntent = getFocusIntent(event, context.orientation, context.dir);
+				if (focusIntent !== void 0) {
+					if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return;
+					event.preventDefault();
+					let candidateNodes = getItems().filter((item) => item.focusable).map((item) => item.ref.current);
+					if (focusIntent === "last") candidateNodes.reverse();
+					else if (focusIntent === "prev" || focusIntent === "next") {
+						if (focusIntent === "prev") candidateNodes.reverse();
+						const currentIndex = candidateNodes.indexOf(event.currentTarget);
+						candidateNodes = context.loop ? wrapArray(candidateNodes, currentIndex + 1) : candidateNodes.slice(currentIndex + 1);
+					}
+					setTimeout(() => focusFirst(candidateNodes));
+				}
+			}),
+			children: typeof children === "function" ? children({
+				isCurrentTabStop,
+				hasTabStop: currentTabStopId != null
+			}) : children
+		})
+	});
+});
+RovingFocusGroupItem.displayName = ITEM_NAME;
+var MAP_KEY_TO_FOCUS_INTENT = {
+	ArrowLeft: "prev",
+	ArrowUp: "prev",
+	ArrowRight: "next",
+	ArrowDown: "next",
+	PageUp: "first",
+	Home: "first",
+	PageDown: "last",
+	End: "last"
+};
+function getDirectionAwareKey(key, dir) {
+	if (dir !== "rtl") return key;
+	return key === "ArrowLeft" ? "ArrowRight" : key === "ArrowRight" ? "ArrowLeft" : key;
+}
+function getFocusIntent(event, orientation, dir) {
+	const key = getDirectionAwareKey(event.key, dir);
+	if (orientation === "vertical" && ["ArrowLeft", "ArrowRight"].includes(key)) return void 0;
+	if (orientation === "horizontal" && ["ArrowUp", "ArrowDown"].includes(key)) return void 0;
+	return MAP_KEY_TO_FOCUS_INTENT[key];
+}
+function focusFirst(candidates, preventScroll = false) {
+	const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
+	for (const candidate of candidates) {
+		if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;
+		candidate.focus({ preventScroll });
+		if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
+	}
+}
+function wrapArray(array, startIndex) {
+	return array.map((_, index) => array[(startIndex + index) % array.length]);
+}
+var Root = RovingFocusGroup;
+var Item = RovingFocusGroupItem;
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-presence@1.1.5_@types+react-dom@19.2.3_@types+react@19.2.7__@types+reac_90b29b5754215655309320557426a63a/node_modules/@radix-ui/react-presence/dist/index.mjs
+function useStateMachine(initialState, machine) {
+	return React$1.useReducer((state, event) => {
+		return machine[state][event] ?? state;
+	}, initialState);
+}
+var Presence = (props) => {
+	const { present, children } = props;
+	const presence = usePresence(present);
+	const child = typeof children === "function" ? children({ present: presence.isPresent }) : React$1.Children.only(children);
+	const ref = useComposedRefs(presence.ref, getElementRef(child));
+	return typeof children === "function" || presence.isPresent ? React$1.cloneElement(child, { ref }) : null;
+};
+Presence.displayName = "Presence";
+function usePresence(present) {
+	const [node, setNode] = React$1.useState();
+	const stylesRef = React$1.useRef(null);
+	const prevPresentRef = React$1.useRef(present);
+	const prevAnimationNameRef = React$1.useRef("none");
+	const [state, send] = useStateMachine(present ? "mounted" : "unmounted", {
+		mounted: {
+			UNMOUNT: "unmounted",
+			ANIMATION_OUT: "unmountSuspended"
+		},
+		unmountSuspended: {
+			MOUNT: "mounted",
+			ANIMATION_END: "unmounted"
+		},
+		unmounted: { MOUNT: "mounted" }
+	});
+	React$1.useEffect(() => {
+		const currentAnimationName = getAnimationName(stylesRef.current);
+		prevAnimationNameRef.current = state === "mounted" ? currentAnimationName : "none";
+	}, [state]);
+	useLayoutEffect2(() => {
+		const styles = stylesRef.current;
+		const wasPresent = prevPresentRef.current;
+		if (wasPresent !== present) {
+			const prevAnimationName = prevAnimationNameRef.current;
+			const currentAnimationName = getAnimationName(styles);
+			if (present) send("MOUNT");
+			else if (currentAnimationName === "none" || styles?.display === "none") send("UNMOUNT");
+			else if (wasPresent && prevAnimationName !== currentAnimationName) send("ANIMATION_OUT");
+			else send("UNMOUNT");
+			prevPresentRef.current = present;
+		}
+	}, [present, send]);
+	useLayoutEffect2(() => {
+		if (node) {
+			let timeoutId;
+			const ownerWindow = node.ownerDocument.defaultView ?? window;
+			const handleAnimationEnd = (event) => {
+				const isCurrentAnimation = getAnimationName(stylesRef.current).includes(CSS.escape(event.animationName));
+				if (event.target === node && isCurrentAnimation) {
+					send("ANIMATION_END");
+					if (!prevPresentRef.current) {
+						const currentFillMode = node.style.animationFillMode;
+						node.style.animationFillMode = "forwards";
+						timeoutId = ownerWindow.setTimeout(() => {
+							if (node.style.animationFillMode === "forwards") node.style.animationFillMode = currentFillMode;
+						});
+					}
+				}
+			};
+			const handleAnimationStart = (event) => {
+				if (event.target === node) prevAnimationNameRef.current = getAnimationName(stylesRef.current);
+			};
+			node.addEventListener("animationstart", handleAnimationStart);
+			node.addEventListener("animationcancel", handleAnimationEnd);
+			node.addEventListener("animationend", handleAnimationEnd);
+			return () => {
+				ownerWindow.clearTimeout(timeoutId);
+				node.removeEventListener("animationstart", handleAnimationStart);
+				node.removeEventListener("animationcancel", handleAnimationEnd);
+				node.removeEventListener("animationend", handleAnimationEnd);
+			};
+		} else send("ANIMATION_END");
+	}, [node, send]);
+	return {
+		isPresent: ["mounted", "unmountSuspended"].includes(state),
+		ref: React$1.useCallback((node2) => {
+			stylesRef.current = node2 ? getComputedStyle(node2) : null;
+			setNode(node2);
+		}, [])
+	};
+}
+function getAnimationName(styles) {
+	return styles?.animationName || "none";
+}
+function getElementRef(element) {
+	let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+	let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+	if (mayWarn) return element.ref;
+	getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+	mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+	if (mayWarn) return element.props.ref;
+	return element.props.ref || element.ref;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@radix-ui+react-tabs@1.1.13_@types+react-dom@19.2.3_@types+react@19.2.7__@types+react@1_dc861e27c2a200eb839e0d3bcc9fb0d9/node_modules/@radix-ui/react-tabs/dist/index.mjs
+var TABS_NAME = "Tabs";
+var [createTabsContext, createTabsScope] = createContextScope(TABS_NAME, [createRovingFocusGroupScope]);
+var useRovingFocusGroupScope = createRovingFocusGroupScope();
+var [TabsProvider, useTabsContext] = createTabsContext(TABS_NAME);
+var Tabs$1 = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeTabs, value: valueProp, onValueChange, defaultValue, orientation = "horizontal", dir, activationMode = "automatic", ...tabsProps } = props;
+	const direction = useDirection(dir);
+	const [value, setValue] = useControllableState({
+		prop: valueProp,
+		onChange: onValueChange,
+		defaultProp: defaultValue ?? "",
+		caller: TABS_NAME
+	});
+	return /* @__PURE__ */ jsx(TabsProvider, {
+		scope: __scopeTabs,
+		baseId: useId$1(),
+		value,
+		onValueChange: setValue,
+		orientation,
+		dir: direction,
+		activationMode,
+		children: /* @__PURE__ */ jsx(Primitive.div, {
+			dir: direction,
+			"data-orientation": orientation,
+			...tabsProps,
+			ref: forwardedRef
+		})
+	});
+});
+Tabs$1.displayName = TABS_NAME;
+var TAB_LIST_NAME = "TabsList";
+var TabsList$1 = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeTabs, loop = true, ...listProps } = props;
+	const context = useTabsContext(TAB_LIST_NAME, __scopeTabs);
+	const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeTabs);
+	return /* @__PURE__ */ jsx(Root, {
+		asChild: true,
+		...rovingFocusGroupScope,
+		orientation: context.orientation,
+		dir: context.dir,
+		loop,
+		children: /* @__PURE__ */ jsx(Primitive.div, {
+			role: "tablist",
+			"aria-orientation": context.orientation,
+			...listProps,
+			ref: forwardedRef
+		})
+	});
+});
+TabsList$1.displayName = TAB_LIST_NAME;
+var TRIGGER_NAME = "TabsTrigger";
+var TabsTrigger$1 = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeTabs, value, disabled = false, ...triggerProps } = props;
+	const context = useTabsContext(TRIGGER_NAME, __scopeTabs);
+	const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeTabs);
+	const triggerId = makeTriggerId(context.baseId, value);
+	const contentId = makeContentId(context.baseId, value);
+	const isSelected = value === context.value;
+	return /* @__PURE__ */ jsx(Item, {
+		asChild: true,
+		...rovingFocusGroupScope,
+		focusable: !disabled,
+		active: isSelected,
+		children: /* @__PURE__ */ jsx(Primitive.button, {
+			type: "button",
+			role: "tab",
+			"aria-selected": isSelected,
+			"aria-controls": contentId,
+			"data-state": isSelected ? "active" : "inactive",
+			"data-disabled": disabled ? "" : void 0,
+			disabled,
+			id: triggerId,
+			...triggerProps,
+			ref: forwardedRef,
+			onMouseDown: composeEventHandlers(props.onMouseDown, (event) => {
+				if (!disabled && event.button === 0 && event.ctrlKey === false) context.onValueChange(value);
+				else event.preventDefault();
+			}),
+			onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
+				if ([" ", "Enter"].includes(event.key)) context.onValueChange(value);
+			}),
+			onFocus: composeEventHandlers(props.onFocus, () => {
+				const isAutomaticActivation = context.activationMode !== "manual";
+				if (!isSelected && !disabled && isAutomaticActivation) context.onValueChange(value);
+			})
+		})
+	});
+});
+TabsTrigger$1.displayName = TRIGGER_NAME;
+var CONTENT_NAME = "TabsContent";
+var TabsContent = React$1.forwardRef((props, forwardedRef) => {
+	const { __scopeTabs, value, forceMount, children, ...contentProps } = props;
+	const context = useTabsContext(CONTENT_NAME, __scopeTabs);
+	const triggerId = makeTriggerId(context.baseId, value);
+	const contentId = makeContentId(context.baseId, value);
+	const isSelected = value === context.value;
+	const isMountAnimationPreventedRef = React$1.useRef(isSelected);
+	React$1.useEffect(() => {
+		const rAF = requestAnimationFrame(() => isMountAnimationPreventedRef.current = false);
+		return () => cancelAnimationFrame(rAF);
+	}, []);
+	return /* @__PURE__ */ jsx(Presence, {
+		present: forceMount || isSelected,
+		children: ({ present }) => /* @__PURE__ */ jsx(Primitive.div, {
+			"data-state": isSelected ? "active" : "inactive",
+			"data-orientation": context.orientation,
+			role: "tabpanel",
+			"aria-labelledby": triggerId,
+			hidden: !present,
+			id: contentId,
+			tabIndex: 0,
+			...contentProps,
+			ref: forwardedRef,
+			style: {
+				...props.style,
+				animationDuration: isMountAnimationPreventedRef.current ? "0s" : void 0
+			},
+			children: present && children
+		})
+	});
+});
+TabsContent.displayName = CONTENT_NAME;
+function makeTriggerId(baseId, value) {
+	return `${baseId}-trigger-${value}`;
+}
+function makeContentId(baseId, value) {
+	return `${baseId}-content-${value}`;
+}
+var Root2 = Tabs$1;
+var List = TabsList$1;
+var Trigger = TabsTrigger$1;
+//#endregion
+//#region ../ui/src/components/primitives/tabs.tsx
+var TabsContext = React$1.createContext({
+	variant: "default",
+	orientation: "horizontal"
+});
+function Tabs({ className, variant = "default", orientation = "horizontal", ...props }) {
+	return /* @__PURE__ */ jsx(TabsContext, {
+		value: {
+			variant,
+			orientation
+		},
+		children: /* @__PURE__ */ jsx(Root2, {
+			"data-slot": "tabs",
+			orientation,
+			className: cn("flex flex-col gap-2", orientation === "vertical" && "flex-row", className),
+			...props
+		})
+	});
+}
+var tabsListVariants = cva("inline-flex items-center justify-center", {
+	variants: {
+		variant: {
+			default: "h-9 w-fit rounded-lg bg-muted p-[3px] text-muted-foreground",
+			line: "justify-start gap-4 border-b-0 bg-transparent p-0",
+			underline: "justify-start gap-0 border-b-0 bg-transparent p-0",
+			workflow: "justify-start gap-3 border-b-0 bg-transparent p-0"
+		},
+		orientation: {
+			horizontal: "flex-row",
+			vertical: "h-fit flex-col"
+		}
+	},
+	compoundVariants: [{
+		variant: "default",
+		orientation: "vertical",
+		class: "h-fit w-fit flex-col"
+	}, {
+		variant: "line",
+		orientation: "vertical",
+		class: "flex-col items-stretch pb-0"
+	}],
+	defaultVariants: {
+		variant: "default",
+		orientation: "horizontal"
+	}
+});
+function TabsList({ className, ...props }) {
+	const { variant, orientation } = React$1.use(TabsContext);
+	return /* @__PURE__ */ jsx(List, {
+		"data-slot": "tabs-list",
+		className: cn(tabsListVariants({
+			variant,
+			orientation
+		}), className),
+		...props
+	});
+}
+var tabsTriggerVariants = cva([
+	"inline-flex items-center justify-center text-sm font-medium whitespace-nowrap",
+	"disabled:pointer-events-none disabled:opacity-50",
+	"transition-all outline-none",
+	"[&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*=\"size-\"])]:size-4"
+], {
+	variants: {
+		variant: {
+			default: [
+				"h-[calc(100%-1px)] flex-1 gap-1.5 rounded-md px-2 py-1",
+				"border border-transparent text-foreground",
+				"dark:text-muted-foreground",
+				"focus-visible:border-primary focus-visible:bg-accent",
+				"data-[state=active]:bg-background data-[state=active]:shadow-sm",
+				"dark:data-[state=active]:border-input dark:data-[state=active]:bg-input/30 dark:data-[state=active]:text-foreground"
+			],
+			line: [
+				"relative gap-2 px-2 py-2",
+				"font-normal text-muted-foreground hover:text-foreground",
+				"focus-visible:text-foreground focus-visible:underline focus-visible:underline-offset-4",
+				"data-[state=active]:text-primary",
+				"after:absolute after:rounded-full after:bg-transparent",
+				"data-[state=active]:after:bg-primary"
+			],
+			underline: [
+				"relative gap-1.5 px-2.5 py-2",
+				"font-normal text-muted-foreground hover:text-foreground",
+				"focus-visible:text-foreground focus-visible:underline focus-visible:underline-offset-4",
+				"data-[state=active]:text-foreground",
+				"after:absolute after:rounded-none after:bg-transparent",
+				"data-[state=active]:after:bg-primary"
+			],
+			workflow: [
+				"relative gap-1.5 px-1 py-1.5 text-sm font-normal",
+				"text-muted-foreground hover:text-foreground",
+				"rounded-sm focus-visible:text-foreground focus-visible:underline focus-visible:underline-offset-4",
+				"data-[state=active]:font-semibold data-[state=active]:text-foreground",
+				"data-[state=active]:underline data-[state=active]:decoration-1 data-[state=active]:underline-offset-4",
+				"[&:not(:first-child)]:before:content-['›']",
+				"[&:not(:first-child)]:before:mr-3 [&:not(:first-child)]:before:text-base",
+				"[&:not(:first-child)]:before:font-normal [&:not(:first-child)]:before:no-underline",
+				"[&:not(:first-child)]:before:text-muted-foreground"
+			]
+		},
+		orientation: {
+			horizontal: "",
+			vertical: "rounded-full"
+		}
+	},
+	compoundVariants: [
+		{
+			variant: "line",
+			orientation: "horizontal",
+			class: "after:bottom-0 after:left-0 after:h-[2px] after:w-full data-[state=active]:after:h-[4px]"
+		},
+		{
+			variant: "line",
+			orientation: "vertical",
+			class: ["justify-center after:bottom-0 after:left-0 after:h-[4px] after:w-full after:bg-transparent data-[state=active]:after:bg-primary", "hover:bg-primary/10 hover:text-primary"]
+		},
+		{
+			variant: "underline",
+			orientation: "horizontal",
+			class: "after:bottom-0 after:left-0 after:h-0.5 after:w-full"
+		}
+	],
+	defaultVariants: {
+		variant: "default",
+		orientation: "horizontal"
+	}
+});
+function TabsTrigger({ className, ...props }) {
+	const { variant, orientation } = React$1.use(TabsContext);
+	return /* @__PURE__ */ jsx(Trigger, {
+		"data-slot": "tabs-trigger",
+		className: cn(tabsTriggerVariants({
+			variant,
+			orientation
+		}), className),
+		...props
+	});
+}
+//#endregion
+//#region src/plugins/spreadsheet/SpreadsheetFilePreviewToolbar.tsx
+function SpreadsheetFilePreviewToolbar({ canZoomIn, canZoomOut, onZoomIn, onZoomOut, zoomLabel }) {
+	const { t } = useTranslation();
+	return /* @__PURE__ */ jsxs("div", {
+		role: "toolbar",
+		"aria-label": t("preview.label"),
+		className: "flex shrink-0 items-center gap-1",
+		children: [
+			/* @__PURE__ */ jsx(FilePreviewToolbarButton, {
+				label: t("preview.zoom_out"),
+				disabled: !canZoomOut,
+				onClick: onZoomOut,
+				children: /* @__PURE__ */ jsx(ZoomOut, { "aria-hidden": true })
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "min-w-12 px-1 text-center text-muted-foreground text-xs tabular-nums",
+				"data-testid": "xlsx-preview-zoom-value",
+				children: zoomLabel
+			}),
+			/* @__PURE__ */ jsx(FilePreviewToolbarButton, {
+				label: t("preview.zoom_in"),
+				disabled: !canZoomIn,
+				onClick: onZoomIn,
+				children: /* @__PURE__ */ jsx(ZoomIn, { "aria-hidden": true })
+			})
+		]
+	});
+}
+//#endregion
+//#region src/plugins/spreadsheet/useXlsxWorkbook.ts
+/** Files above this size are not parsed and fall back to opening in an external app. */
+var XLSX_PREVIEW_MAX_SIZE_BYTES = 20971520;
+function useXlsxWorkbook(document, fileName) {
+	const logger = usePreviewLogger("useXlsxWorkbook");
+	const { failDocument, resources } = usePreviewHost();
+	const { baseUrl, createWorker } = resources ?? {};
+	const [state, setState] = useState({ status: "idle" });
+	const workerRef = useRef(null);
+	const requestIdRef = useRef(0);
+	const loggedWarningsRef = useRef(/* @__PURE__ */ new Set());
+	useEffect(() => {
+		let cancelled = false;
+		const controller = new AbortController();
+		const requestId = ++requestIdRef.current;
+		if (document.size > 20971520) {
+			failDocument?.(new PreviewError("too_large", "Workbook exceeds the preview size limit"));
+			setState({
+				status: "oversize",
+				sizeBytes: document.size
+			});
+			return;
+		}
+		setState({ status: "loading" });
+		(async () => {
+			let bytes;
+			try {
+				const raw = await readPreviewDocument(document, XLSX_PREVIEW_MAX_SIZE_BYTES, controller.signal);
+				if (cancelled || requestId !== requestIdRef.current) return;
+				bytes = raw.slice().buffer;
+			} catch (error) {
+				if (cancelled || requestId !== requestIdRef.current) return;
+				const normalized = error instanceof Error ? error : new Error(String(error));
+				failDocument?.(normalized);
+				setState({
+					status: "error",
+					message: normalized.message
+				});
+				return;
+			}
+			let worker;
+			try {
+				worker = createXlsxWorker(baseUrl, createWorker);
+			} catch (error) {
+				if (cancelled || requestId !== requestIdRef.current) return;
+				const normalized = error instanceof Error ? error : new Error(String(error));
+				failDocument?.(normalized);
+				setState({
+					status: "error",
+					message: normalized.message
+				});
+				return;
+			}
+			if (cancelled || requestId !== requestIdRef.current) {
+				worker.terminate();
+				return;
+			}
+			workerRef.current = worker;
+			worker.onmessage = (event) => {
+				if (cancelled || event.data.id !== requestIdRef.current) return;
+				worker.terminate();
+				if (workerRef.current === worker) workerRef.current = null;
+				if (event.data.ok) {
+					for (const warning of event.data.model.warnings) {
+						if (loggedWarningsRef.current.has(warning)) continue;
+						loggedWarningsRef.current.add(warning);
+						logger.warn(warning);
+					}
+					setState({
+						status: "ready",
+						model: event.data.model
+					});
+				} else {
+					failDocument?.(new Error(event.data.message));
+					setState({
+						status: "error",
+						message: event.data.message
+					});
+				}
+			};
+			worker.onerror = (event) => {
+				if (cancelled || requestId !== requestIdRef.current) return;
+				worker.terminate();
+				if (workerRef.current === worker) workerRef.current = null;
+				failDocument?.(event.error instanceof Error ? event.error : new Error(event.message));
+				setState({
+					status: "error",
+					message: event.message
+				});
+			};
+			const request = {
+				id: requestId,
+				fileName,
+				data: bytes
+			};
+			try {
+				worker.postMessage(request, [bytes]);
+			} catch (error) {
+				worker.terminate();
+				if (workerRef.current === worker) workerRef.current = null;
+				if (cancelled || requestId !== requestIdRef.current) return;
+				const normalized = error instanceof Error ? error : new Error(String(error));
+				failDocument?.(normalized);
+				setState({
+					status: "error",
+					message: normalized.message
+				});
+			}
+		})();
+		return () => {
+			cancelled = true;
+			controller.abort();
+			workerRef.current?.terminate();
+			workerRef.current = null;
+		};
+	}, [
+		document,
+		fileName,
+		logger,
+		failDocument,
+		baseUrl,
+		createWorker
+	]);
+	return state;
+}
+function createXlsxWorker(baseUrl, createWorker) {
+	if (createWorker) return createWorker("xlsx");
+	if (baseUrl) return new Worker(new URL("xlsx.worker.js", new URL(baseUrl, document.baseURI)), { type: "module" });
+	return new Worker(new URL(
+		/* @vite-ignore */
+		"" + new URL("assets/xlsx.worker.js", import.meta.url).href,
+		"" + import.meta.url
+	), { type: "module" });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+virtual-core@3.14.0/node_modules/@tanstack/virtual-core/dist/esm/utils.js
+function memo$1(getDeps, fn, opts) {
+	let deps = opts.initialDeps ?? [];
+	let result;
+	let isInitial = true;
+	function memoizedFunction() {
+		var _a, _b, _c;
+		let depTime;
+		if (opts.key && ((_a = opts.debug) == null ? void 0 : _a.call(opts))) depTime = Date.now();
+		const newDeps = getDeps();
+		if (!(newDeps.length !== deps.length || newDeps.some((dep, index) => deps[index] !== dep))) return result;
+		deps = newDeps;
+		let resultTime;
+		if (opts.key && ((_b = opts.debug) == null ? void 0 : _b.call(opts))) resultTime = Date.now();
+		result = fn(...newDeps);
+		if (opts.key && ((_c = opts.debug) == null ? void 0 : _c.call(opts))) {
+			const depEndTime = Math.round((Date.now() - depTime) * 100) / 100;
+			const resultEndTime = Math.round((Date.now() - resultTime) * 100) / 100;
+			const resultFpsPercentage = resultEndTime / 16;
+			const pad = (str, num) => {
+				str = String(str);
+				while (str.length < num) str = " " + str;
+				return str;
+			};
+			console.info(`%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`, `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(0, Math.min(120 - 120 * resultFpsPercentage, 120))}deg 100% 31%);`, opts == null ? void 0 : opts.key);
+		}
+		if ((opts == null ? void 0 : opts.onChange) && !(isInitial && opts.skipInitialOnChange)) opts.onChange(result);
+		isInitial = false;
+		return result;
+	}
+	memoizedFunction.updateDeps = (newDeps) => {
+		deps = newDeps;
+	};
+	return memoizedFunction;
+}
+function notUndefined(value, msg) {
+	if (value === void 0) throw new Error(`Unexpected undefined${msg ? `: ${msg}` : ""}`);
+	else return value;
+}
+var approxEqual = (a, b) => Math.abs(a - b) < 1.01;
+var debounce = (targetWindow, fn, ms) => {
+	let timeoutId;
+	return function(...args) {
+		targetWindow.clearTimeout(timeoutId);
+		timeoutId = targetWindow.setTimeout(() => fn.apply(this, args), ms);
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+virtual-core@3.14.0/node_modules/@tanstack/virtual-core/dist/esm/index.js
+var getRect = (element) => {
+	const { offsetWidth, offsetHeight } = element;
+	return {
+		width: offsetWidth,
+		height: offsetHeight
+	};
+};
+var defaultKeyExtractor = (index) => index;
+var defaultRangeExtractor = (range) => {
+	const start = Math.max(range.startIndex - range.overscan, 0);
+	const end = Math.min(range.endIndex + range.overscan, range.count - 1);
+	const arr = [];
+	for (let i = start; i <= end; i++) arr.push(i);
+	return arr;
+};
+var observeElementRect = (instance, cb) => {
+	const element = instance.scrollElement;
+	if (!element) return;
+	const targetWindow = instance.targetWindow;
+	if (!targetWindow) return;
+	const handler = (rect) => {
+		const { width, height } = rect;
+		cb({
+			width: Math.round(width),
+			height: Math.round(height)
+		});
+	};
+	handler(getRect(element));
+	if (!targetWindow.ResizeObserver) return () => {};
+	const observer = new targetWindow.ResizeObserver((entries) => {
+		const run = () => {
+			const entry = entries[0];
+			if (entry == null ? void 0 : entry.borderBoxSize) {
+				const box = entry.borderBoxSize[0];
+				if (box) {
+					handler({
+						width: box.inlineSize,
+						height: box.blockSize
+					});
+					return;
+				}
+			}
+			handler(getRect(element));
+		};
+		instance.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(run) : run();
+	});
+	observer.observe(element, { box: "border-box" });
+	return () => {
+		observer.unobserve(element);
+	};
+};
+var addEventListenerOptions = { passive: true };
+var supportsScrollend = typeof window == "undefined" ? true : "onscrollend" in window;
+var observeElementOffset = (instance, cb) => {
+	const element = instance.scrollElement;
+	if (!element) return;
+	const targetWindow = instance.targetWindow;
+	if (!targetWindow) return;
+	let offset = 0;
+	const fallback = instance.options.useScrollendEvent && supportsScrollend ? () => void 0 : debounce(targetWindow, () => {
+		cb(offset, false);
+	}, instance.options.isScrollingResetDelay);
+	const createHandler = (isScrolling) => () => {
+		const { horizontal, isRtl } = instance.options;
+		offset = horizontal ? element["scrollLeft"] * (isRtl && -1 || 1) : element["scrollTop"];
+		fallback();
+		cb(offset, isScrolling);
+	};
+	const handler = createHandler(true);
+	const endHandler = createHandler(false);
+	element.addEventListener("scroll", handler, addEventListenerOptions);
+	const registerScrollendEvent = instance.options.useScrollendEvent && supportsScrollend;
+	if (registerScrollendEvent) element.addEventListener("scrollend", endHandler, addEventListenerOptions);
+	return () => {
+		element.removeEventListener("scroll", handler);
+		if (registerScrollendEvent) element.removeEventListener("scrollend", endHandler);
+	};
+};
+var measureElement = (element, entry, instance) => {
+	if (entry == null ? void 0 : entry.borderBoxSize) {
+		const box = entry.borderBoxSize[0];
+		if (box) return Math.round(box[instance.options.horizontal ? "inlineSize" : "blockSize"]);
+	}
+	return element[instance.options.horizontal ? "offsetWidth" : "offsetHeight"];
+};
+var elementScroll = (offset, { adjustments = 0, behavior }, instance) => {
+	var _a, _b;
+	const toOffset = offset + adjustments;
+	(_b = (_a = instance.scrollElement) == null ? void 0 : _a.scrollTo) == null || _b.call(_a, {
+		[instance.options.horizontal ? "left" : "top"]: toOffset,
+		behavior
+	});
+};
+var Virtualizer = class {
+	constructor(opts) {
+		this.unsubs = [];
+		this.scrollElement = null;
+		this.targetWindow = null;
+		this.isScrolling = false;
+		this.scrollState = null;
+		this.measurementsCache = [];
+		this.itemSizeCache = /* @__PURE__ */ new Map();
+		this.laneAssignments = /* @__PURE__ */ new Map();
+		this.pendingMeasuredCacheIndexes = [];
+		this.prevLanes = void 0;
+		this.lanesChangedFlag = false;
+		this.lanesSettling = false;
+		this.scrollRect = null;
+		this.scrollOffset = null;
+		this.scrollDirection = null;
+		this.scrollAdjustments = 0;
+		this.elementsCache = /* @__PURE__ */ new Map();
+		this.now = () => {
+			var _a, _b, _c;
+			return ((_c = (_b = (_a = this.targetWindow) == null ? void 0 : _a.performance) == null ? void 0 : _b.now) == null ? void 0 : _c.call(_b)) ?? Date.now();
+		};
+		this.observer = /* @__PURE__ */ (() => {
+			let _ro = null;
+			const get = () => {
+				if (_ro) return _ro;
+				if (!this.targetWindow || !this.targetWindow.ResizeObserver) return null;
+				return _ro = new this.targetWindow.ResizeObserver((entries) => {
+					entries.forEach((entry) => {
+						const run = () => {
+							const node = entry.target;
+							const index = this.indexFromElement(node);
+							if (!node.isConnected) {
+								this.observer.unobserve(node);
+								return;
+							}
+							if (this.shouldMeasureDuringScroll(index)) this.resizeItem(index, this.options.measureElement(node, entry, this));
+						};
+						this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(run) : run();
+					});
+				});
+			};
+			return {
+				disconnect: () => {
+					var _a;
+					(_a = get()) == null || _a.disconnect();
+					_ro = null;
+				},
+				observe: (target) => {
+					var _a;
+					return (_a = get()) == null ? void 0 : _a.observe(target, { box: "border-box" });
+				},
+				unobserve: (target) => {
+					var _a;
+					return (_a = get()) == null ? void 0 : _a.unobserve(target);
+				}
+			};
+		})();
+		this.range = null;
+		this.setOptions = (opts2) => {
+			Object.entries(opts2).forEach(([key, value]) => {
+				if (typeof value === "undefined") delete opts2[key];
+			});
+			this.options = {
+				debug: false,
+				initialOffset: 0,
+				overscan: 1,
+				paddingStart: 0,
+				paddingEnd: 0,
+				scrollPaddingStart: 0,
+				scrollPaddingEnd: 0,
+				horizontal: false,
+				getItemKey: defaultKeyExtractor,
+				rangeExtractor: defaultRangeExtractor,
+				onChange: () => {},
+				measureElement,
+				initialRect: {
+					width: 0,
+					height: 0
+				},
+				scrollMargin: 0,
+				gap: 0,
+				indexAttribute: "data-index",
+				initialMeasurementsCache: [],
+				lanes: 1,
+				isScrollingResetDelay: 150,
+				enabled: true,
+				isRtl: false,
+				useScrollendEvent: false,
+				useAnimationFrameWithResizeObserver: false,
+				laneAssignmentMode: "estimate",
+				...opts2
+			};
+		};
+		this.notify = (sync) => {
+			var _a, _b;
+			(_b = (_a = this.options).onChange) == null || _b.call(_a, this, sync);
+		};
+		this.maybeNotify = memo$1(() => {
+			this.calculateRange();
+			return [
+				this.isScrolling,
+				this.range ? this.range.startIndex : null,
+				this.range ? this.range.endIndex : null
+			];
+		}, (isScrolling) => {
+			this.notify(isScrolling);
+		}, {
+			key: false,
+			debug: () => this.options.debug,
+			initialDeps: [
+				this.isScrolling,
+				this.range ? this.range.startIndex : null,
+				this.range ? this.range.endIndex : null
+			]
+		});
+		this.cleanup = () => {
+			this.unsubs.filter(Boolean).forEach((d) => d());
+			this.unsubs = [];
+			this.observer.disconnect();
+			if (this.rafId != null && this.targetWindow) {
+				this.targetWindow.cancelAnimationFrame(this.rafId);
+				this.rafId = null;
+			}
+			this.scrollState = null;
+			this.scrollElement = null;
+			this.targetWindow = null;
+		};
+		this._didMount = () => {
+			return () => {
+				this.cleanup();
+			};
+		};
+		this._willUpdate = () => {
+			var _a;
+			const scrollElement = this.options.enabled ? this.options.getScrollElement() : null;
+			if (this.scrollElement !== scrollElement) {
+				this.cleanup();
+				if (!scrollElement) {
+					this.maybeNotify();
+					return;
+				}
+				this.scrollElement = scrollElement;
+				if (this.scrollElement && "ownerDocument" in this.scrollElement) this.targetWindow = this.scrollElement.ownerDocument.defaultView;
+				else this.targetWindow = ((_a = this.scrollElement) == null ? void 0 : _a.window) ?? null;
+				this.elementsCache.forEach((cached) => {
+					this.observer.observe(cached);
+				});
+				this.unsubs.push(this.options.observeElementRect(this, (rect) => {
+					this.scrollRect = rect;
+					this.maybeNotify();
+				}));
+				this.unsubs.push(this.options.observeElementOffset(this, (offset, isScrolling) => {
+					this.scrollAdjustments = 0;
+					this.scrollDirection = isScrolling ? this.getScrollOffset() < offset ? "forward" : "backward" : null;
+					this.scrollOffset = offset;
+					this.isScrolling = isScrolling;
+					if (this.scrollState) this.scheduleScrollReconcile();
+					this.maybeNotify();
+				}));
+				this._scrollToOffset(this.getScrollOffset(), {
+					adjustments: void 0,
+					behavior: void 0
+				});
+			}
+		};
+		this.rafId = null;
+		this.getSize = () => {
+			if (!this.options.enabled) {
+				this.scrollRect = null;
+				return 0;
+			}
+			this.scrollRect = this.scrollRect ?? this.options.initialRect;
+			return this.scrollRect[this.options.horizontal ? "width" : "height"];
+		};
+		this.getScrollOffset = () => {
+			if (!this.options.enabled) {
+				this.scrollOffset = null;
+				return 0;
+			}
+			this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset === "function" ? this.options.initialOffset() : this.options.initialOffset);
+			return this.scrollOffset;
+		};
+		this.getFurthestMeasurement = (measurements, index) => {
+			const furthestMeasurementsFound = /* @__PURE__ */ new Map();
+			const furthestMeasurements = /* @__PURE__ */ new Map();
+			for (let m = index - 1; m >= 0; m--) {
+				const measurement = measurements[m];
+				if (furthestMeasurementsFound.has(measurement.lane)) continue;
+				const previousFurthestMeasurement = furthestMeasurements.get(measurement.lane);
+				if (previousFurthestMeasurement == null || measurement.end > previousFurthestMeasurement.end) furthestMeasurements.set(measurement.lane, measurement);
+				else if (measurement.end < previousFurthestMeasurement.end) furthestMeasurementsFound.set(measurement.lane, true);
+				if (furthestMeasurementsFound.size === this.options.lanes) break;
+			}
+			return furthestMeasurements.size === this.options.lanes ? Array.from(furthestMeasurements.values()).sort((a, b) => {
+				if (a.end === b.end) return a.index - b.index;
+				return a.end - b.end;
+			})[0] : void 0;
+		};
+		this.getMeasurementOptions = memo$1(() => [
+			this.options.count,
+			this.options.paddingStart,
+			this.options.scrollMargin,
+			this.options.getItemKey,
+			this.options.enabled,
+			this.options.lanes,
+			this.options.laneAssignmentMode
+		], (count, paddingStart, scrollMargin, getItemKey, enabled, lanes, laneAssignmentMode) => {
+			if (this.prevLanes !== void 0 && this.prevLanes !== lanes) this.lanesChangedFlag = true;
+			this.prevLanes = lanes;
+			this.pendingMeasuredCacheIndexes = [];
+			return {
+				count,
+				paddingStart,
+				scrollMargin,
+				getItemKey,
+				enabled,
+				lanes,
+				laneAssignmentMode
+			};
+		}, { key: false });
+		this.getMeasurements = memo$1(() => [this.getMeasurementOptions(), this.itemSizeCache], ({ count, paddingStart, scrollMargin, getItemKey, enabled, lanes, laneAssignmentMode }, itemSizeCache) => {
+			if (!enabled) {
+				this.measurementsCache = [];
+				this.itemSizeCache.clear();
+				this.laneAssignments.clear();
+				return [];
+			}
+			if (this.laneAssignments.size > count) {
+				for (const index of this.laneAssignments.keys()) if (index >= count) this.laneAssignments.delete(index);
+			}
+			if (this.lanesChangedFlag) {
+				this.lanesChangedFlag = false;
+				this.lanesSettling = true;
+				this.measurementsCache = [];
+				this.itemSizeCache.clear();
+				this.laneAssignments.clear();
+				this.pendingMeasuredCacheIndexes = [];
+			}
+			if (this.measurementsCache.length === 0 && !this.lanesSettling) {
+				this.measurementsCache = this.options.initialMeasurementsCache;
+				this.measurementsCache.forEach((item) => {
+					this.itemSizeCache.set(item.key, item.size);
+				});
+			}
+			const min = this.lanesSettling ? 0 : this.pendingMeasuredCacheIndexes.length > 0 ? Math.min(...this.pendingMeasuredCacheIndexes) : 0;
+			this.pendingMeasuredCacheIndexes = [];
+			if (this.lanesSettling && this.measurementsCache.length === count) this.lanesSettling = false;
+			const measurements = this.measurementsCache.slice(0, min);
+			const laneLastIndex = new Array(lanes).fill(void 0);
+			for (let m = 0; m < min; m++) {
+				const item = measurements[m];
+				if (item) laneLastIndex[item.lane] = m;
+			}
+			for (let i = min; i < count; i++) {
+				const key = getItemKey(i);
+				const cachedLane = this.laneAssignments.get(i);
+				let lane;
+				let start;
+				const shouldCacheLane = laneAssignmentMode === "estimate" || itemSizeCache.has(key);
+				if (cachedLane !== void 0 && this.options.lanes > 1) {
+					lane = cachedLane;
+					const prevIndex = laneLastIndex[lane];
+					const prevInLane = prevIndex !== void 0 ? measurements[prevIndex] : void 0;
+					start = prevInLane ? prevInLane.end + this.options.gap : paddingStart + scrollMargin;
+				} else {
+					const furthestMeasurement = this.options.lanes === 1 ? measurements[i - 1] : this.getFurthestMeasurement(measurements, i);
+					start = furthestMeasurement ? furthestMeasurement.end + this.options.gap : paddingStart + scrollMargin;
+					lane = furthestMeasurement ? furthestMeasurement.lane : i % this.options.lanes;
+					if (this.options.lanes > 1 && shouldCacheLane) this.laneAssignments.set(i, lane);
+				}
+				const measuredSize = itemSizeCache.get(key);
+				const size = typeof measuredSize === "number" ? measuredSize : this.options.estimateSize(i);
+				const end = start + size;
+				measurements[i] = {
+					index: i,
+					start,
+					size,
+					end,
+					key,
+					lane
+				};
+				laneLastIndex[lane] = i;
+			}
+			this.measurementsCache = measurements;
+			return measurements;
+		}, {
+			key: false,
+			debug: () => this.options.debug
+		});
+		this.calculateRange = memo$1(() => [
+			this.getMeasurements(),
+			this.getSize(),
+			this.getScrollOffset(),
+			this.options.lanes
+		], (measurements, outerSize, scrollOffset, lanes) => {
+			return this.range = measurements.length > 0 && outerSize > 0 ? calculateRange({
+				measurements,
+				outerSize,
+				scrollOffset,
+				lanes
+			}) : null;
+		}, {
+			key: false,
+			debug: () => this.options.debug
+		});
+		this.getVirtualIndexes = memo$1(() => {
+			let startIndex = null;
+			let endIndex = null;
+			const range = this.calculateRange();
+			if (range) {
+				startIndex = range.startIndex;
+				endIndex = range.endIndex;
+			}
+			this.maybeNotify.updateDeps([
+				this.isScrolling,
+				startIndex,
+				endIndex
+			]);
+			return [
+				this.options.rangeExtractor,
+				this.options.overscan,
+				this.options.count,
+				startIndex,
+				endIndex
+			];
+		}, (rangeExtractor, overscan, count, startIndex, endIndex) => {
+			return startIndex === null || endIndex === null ? [] : rangeExtractor({
+				startIndex,
+				endIndex,
+				overscan,
+				count
+			});
+		}, {
+			key: false,
+			debug: () => this.options.debug
+		});
+		this.indexFromElement = (node) => {
+			const attributeName = this.options.indexAttribute;
+			const indexStr = node.getAttribute(attributeName);
+			if (!indexStr) {
+				console.warn(`Missing attribute name '${attributeName}={index}' on measured element.`);
+				return -1;
+			}
+			return parseInt(indexStr, 10);
+		};
+		this.shouldMeasureDuringScroll = (index) => {
+			var _a;
+			if (!this.scrollState || this.scrollState.behavior !== "smooth") return true;
+			const scrollIndex = this.scrollState.index ?? ((_a = this.getVirtualItemForOffset(this.scrollState.lastTargetOffset)) == null ? void 0 : _a.index);
+			if (scrollIndex !== void 0 && this.range) {
+				const bufferSize = Math.max(this.options.overscan, Math.ceil((this.range.endIndex - this.range.startIndex) / 2));
+				const minIndex = Math.max(0, scrollIndex - bufferSize);
+				const maxIndex = Math.min(this.options.count - 1, scrollIndex + bufferSize);
+				return index >= minIndex && index <= maxIndex;
+			}
+			return true;
+		};
+		this.measureElement = (node) => {
+			if (!node) {
+				this.elementsCache.forEach((cached, key2) => {
+					if (!cached.isConnected) {
+						this.observer.unobserve(cached);
+						this.elementsCache.delete(key2);
+					}
+				});
+				return;
+			}
+			const index = this.indexFromElement(node);
+			const key = this.options.getItemKey(index);
+			const prevNode = this.elementsCache.get(key);
+			if (prevNode !== node) {
+				if (prevNode) this.observer.unobserve(prevNode);
+				this.observer.observe(node);
+				this.elementsCache.set(key, node);
+			}
+			if ((!this.isScrolling || this.scrollState) && this.shouldMeasureDuringScroll(index)) this.resizeItem(index, this.options.measureElement(node, void 0, this));
+		};
+		this.resizeItem = (index, size) => {
+			var _a;
+			const item = this.measurementsCache[index];
+			if (!item) return;
+			const delta = size - (this.itemSizeCache.get(item.key) ?? item.size);
+			if (delta !== 0) {
+				if (((_a = this.scrollState) == null ? void 0 : _a.behavior) !== "smooth" && (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(item, delta, this) : item.start < this.getScrollOffset() + this.scrollAdjustments)) this._scrollToOffset(this.getScrollOffset(), {
+					adjustments: this.scrollAdjustments += delta,
+					behavior: void 0
+				});
+				this.pendingMeasuredCacheIndexes.push(item.index);
+				this.itemSizeCache = new Map(this.itemSizeCache.set(item.key, size));
+				this.notify(false);
+			}
+		};
+		this.getVirtualItems = memo$1(() => [this.getVirtualIndexes(), this.getMeasurements()], (indexes, measurements) => {
+			const virtualItems = [];
+			for (let k = 0, len = indexes.length; k < len; k++) {
+				const measurement = measurements[indexes[k]];
+				virtualItems.push(measurement);
+			}
+			return virtualItems;
+		}, {
+			key: false,
+			debug: () => this.options.debug
+		});
+		this.getVirtualItemForOffset = (offset) => {
+			const measurements = this.getMeasurements();
+			if (measurements.length === 0) return;
+			return notUndefined(measurements[findNearestBinarySearch(0, measurements.length - 1, (index) => notUndefined(measurements[index]).start, offset)]);
+		};
+		this.getMaxScrollOffset = () => {
+			if (!this.scrollElement) return 0;
+			if ("scrollHeight" in this.scrollElement) return this.options.horizontal ? this.scrollElement.scrollWidth - this.scrollElement.clientWidth : this.scrollElement.scrollHeight - this.scrollElement.clientHeight;
+			else {
+				const doc = this.scrollElement.document.documentElement;
+				return this.options.horizontal ? doc.scrollWidth - this.scrollElement.innerWidth : doc.scrollHeight - this.scrollElement.innerHeight;
+			}
+		};
+		this.getOffsetForAlignment = (toOffset, align, itemSize = 0) => {
+			if (!this.scrollElement) return 0;
+			const size = this.getSize();
+			const scrollOffset = this.getScrollOffset();
+			if (align === "auto") align = toOffset >= scrollOffset + size ? "end" : "start";
+			if (align === "center") toOffset += (itemSize - size) / 2;
+			else if (align === "end") toOffset -= size;
+			const maxOffset = this.getMaxScrollOffset();
+			return Math.max(Math.min(maxOffset, toOffset), 0);
+		};
+		this.getOffsetForIndex = (index, align = "auto") => {
+			index = Math.max(0, Math.min(index, this.options.count - 1));
+			const size = this.getSize();
+			const scrollOffset = this.getScrollOffset();
+			const item = this.measurementsCache[index];
+			if (!item) return;
+			if (align === "auto") {
+				if (item.end >= scrollOffset + size - this.options.scrollPaddingEnd) align = "end";
+				else if (item.start <= scrollOffset + this.options.scrollPaddingStart) align = "start";
+				else return [scrollOffset, align];
+			}
+			if (align === "end" && index === this.options.count - 1) return [this.getMaxScrollOffset(), align];
+			const toOffset = align === "end" ? item.end + this.options.scrollPaddingEnd : item.start - this.options.scrollPaddingStart;
+			return [this.getOffsetForAlignment(toOffset, align, item.size), align];
+		};
+		this.scrollToOffset = (toOffset, { align = "start", behavior = "auto" } = {}) => {
+			const offset = this.getOffsetForAlignment(toOffset, align);
+			const now = this.now();
+			this.scrollState = {
+				index: null,
+				align,
+				behavior,
+				startedAt: now,
+				lastTargetOffset: offset,
+				stableFrames: 0
+			};
+			this._scrollToOffset(offset, {
+				adjustments: void 0,
+				behavior
+			});
+			this.scheduleScrollReconcile();
+		};
+		this.scrollToIndex = (index, { align: initialAlign = "auto", behavior = "auto" } = {}) => {
+			index = Math.max(0, Math.min(index, this.options.count - 1));
+			const offsetInfo = this.getOffsetForIndex(index, initialAlign);
+			if (!offsetInfo) return;
+			const [offset, align] = offsetInfo;
+			const now = this.now();
+			this.scrollState = {
+				index,
+				align,
+				behavior,
+				startedAt: now,
+				lastTargetOffset: offset,
+				stableFrames: 0
+			};
+			this._scrollToOffset(offset, {
+				adjustments: void 0,
+				behavior
+			});
+			this.scheduleScrollReconcile();
+		};
+		this.scrollBy = (delta, { behavior = "auto" } = {}) => {
+			const offset = this.getScrollOffset() + delta;
+			const now = this.now();
+			this.scrollState = {
+				index: null,
+				align: "start",
+				behavior,
+				startedAt: now,
+				lastTargetOffset: offset,
+				stableFrames: 0
+			};
+			this._scrollToOffset(offset, {
+				adjustments: void 0,
+				behavior
+			});
+			this.scheduleScrollReconcile();
+		};
+		this.getTotalSize = () => {
+			var _a;
+			const measurements = this.getMeasurements();
+			let end;
+			if (measurements.length === 0) end = this.options.paddingStart;
+			else if (this.options.lanes === 1) end = ((_a = measurements[measurements.length - 1]) == null ? void 0 : _a.end) ?? 0;
+			else {
+				const endByLane = Array(this.options.lanes).fill(null);
+				let endIndex = measurements.length - 1;
+				while (endIndex >= 0 && endByLane.some((val) => val === null)) {
+					const item = measurements[endIndex];
+					if (endByLane[item.lane] === null) endByLane[item.lane] = item.end;
+					endIndex--;
+				}
+				end = Math.max(...endByLane.filter((val) => val !== null));
+			}
+			return Math.max(end - this.options.scrollMargin + this.options.paddingEnd, 0);
+		};
+		this._scrollToOffset = (offset, { adjustments, behavior }) => {
+			this.options.scrollToFn(offset, {
+				behavior,
+				adjustments
+			}, this);
+		};
+		this.measure = () => {
+			this.itemSizeCache = /* @__PURE__ */ new Map();
+			this.laneAssignments = /* @__PURE__ */ new Map();
+			this.notify(false);
+		};
+		this.setOptions(opts);
+	}
+	scheduleScrollReconcile() {
+		if (!this.targetWindow) {
+			this.scrollState = null;
+			return;
+		}
+		if (this.rafId != null) return;
+		this.rafId = this.targetWindow.requestAnimationFrame(() => {
+			this.rafId = null;
+			this.reconcileScroll();
+		});
+	}
+	reconcileScroll() {
+		if (!this.scrollState) return;
+		if (!this.scrollElement) return;
+		if (this.now() - this.scrollState.startedAt > 5e3) {
+			this.scrollState = null;
+			return;
+		}
+		const offsetInfo = this.scrollState.index != null ? this.getOffsetForIndex(this.scrollState.index, this.scrollState.align) : void 0;
+		const targetOffset = offsetInfo ? offsetInfo[0] : this.scrollState.lastTargetOffset;
+		const STABLE_FRAMES = 1;
+		const targetChanged = targetOffset !== this.scrollState.lastTargetOffset;
+		if (!targetChanged && approxEqual(targetOffset, this.getScrollOffset())) {
+			this.scrollState.stableFrames++;
+			if (this.scrollState.stableFrames >= STABLE_FRAMES) {
+				this.scrollState = null;
+				return;
+			}
+		} else {
+			this.scrollState.stableFrames = 0;
+			if (targetChanged) {
+				this.scrollState.lastTargetOffset = targetOffset;
+				this.scrollState.behavior = "auto";
+				this._scrollToOffset(targetOffset, {
+					adjustments: void 0,
+					behavior: "auto"
+				});
+			}
+		}
+		this.scheduleScrollReconcile();
+	}
+};
+var findNearestBinarySearch = (low, high, getCurrentValue, value) => {
+	while (low <= high) {
+		const middle = (low + high) / 2 | 0;
+		const currentValue = getCurrentValue(middle);
+		if (currentValue < value) low = middle + 1;
+		else if (currentValue > value) high = middle - 1;
+		else return middle;
+	}
+	if (low > 0) return low - 1;
+	else return 0;
+};
+function calculateRange({ measurements, outerSize, scrollOffset, lanes }) {
+	const lastIndex = measurements.length - 1;
+	const getOffset = (index) => measurements[index].start;
+	if (measurements.length <= lanes) return {
+		startIndex: 0,
+		endIndex: lastIndex
+	};
+	let startIndex = findNearestBinarySearch(0, lastIndex, getOffset, scrollOffset);
+	let endIndex = startIndex;
+	if (lanes === 1) while (endIndex < lastIndex && measurements[endIndex].end < scrollOffset + outerSize) endIndex++;
+	else if (lanes > 1) {
+		const endPerLane = Array(lanes).fill(0);
+		while (endIndex < lastIndex && endPerLane.some((pos) => pos < scrollOffset + outerSize)) {
+			const item = measurements[endIndex];
+			endPerLane[item.lane] = item.end;
+			endIndex++;
+		}
+		const startPerLane = Array(lanes).fill(scrollOffset + outerSize);
+		while (startIndex >= 0 && startPerLane.some((pos) => pos >= scrollOffset)) {
+			const item = measurements[startIndex];
+			startPerLane[item.lane] = item.start;
+			startIndex--;
+		}
+		startIndex = Math.max(0, startIndex - startIndex % lanes);
+		endIndex = Math.min(lastIndex, endIndex + (lanes - 1 - endIndex % lanes));
+	}
+	return {
+		startIndex,
+		endIndex
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-virtual@3.13.24_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@tanstack/react-virtual/dist/esm/index.js
+var useIsomorphicLayoutEffect = typeof document !== "undefined" ? React$1.useLayoutEffect : React$1.useEffect;
+function useVirtualizerBase({ useFlushSync = true, ...options }) {
+	const rerender = React$1.useReducer(() => ({}), {})[1];
+	const resolvedOptions = {
+		...options,
+		onChange: (instance2, sync) => {
+			var _a;
+			if (useFlushSync && sync) flushSync(rerender);
+			else rerender();
+			(_a = options.onChange) == null || _a.call(options, instance2, sync);
+		}
+	};
+	const [instance] = React$1.useState(() => new Virtualizer(resolvedOptions));
+	instance.setOptions(resolvedOptions);
+	useIsomorphicLayoutEffect(() => {
+		return instance._didMount();
+	}, []);
+	useIsomorphicLayoutEffect(() => {
+		return instance._willUpdate();
+	});
+	return instance;
+}
+function useVirtualizer(options) {
+	return useVirtualizerBase({
+		observeElementRect,
+		observeElementOffset,
+		scrollToFn: elementScroll,
+		...options
+	});
+}
+//#endregion
+//#region src/plugins/spreadsheet/gridLayout.ts
+/** pt -> px. */
+var ptToPx = (pt) => pt * 96 / 72;
+/** 1-based column number -> 'A' / 'Z' / 'AA'. */
+var colName = (col) => {
+	let name = "";
+	let n = col;
+	while (n > 0) {
+		const rem = (n - 1) % 26;
+		name = String.fromCharCode(65 + rem) + name;
+		n = Math.floor((n - 1) / 26);
+	}
+	return name;
+};
+/** 1-based (row, col) -> 'B4' style address. */
+var cellAddress = (row, col) => `${colName(col)}${row}`;
+/**
+* Builds one axis layout for row heights or column widths, scaled by zoom.
+* @param count Item count (rowCount / colCount).
+* @param defaultSizePx Default size at zoom=1.
+* @param overrides Sparse override table with 1-based keys. Hidden rows/columns map to 0.
+* @param zoom Scale factor.
+*/
+var buildAxisLayout = (count, defaultSizePx, overrides, zoom) => {
+	const sizes = new Array(count);
+	const offsets = new Array(count);
+	let offset = 0;
+	for (let i = 0; i < count; i++) {
+		const size = (overrides[i + 1] ?? defaultSizePx) * zoom;
+		sizes[i] = size;
+		offsets[i] = offset;
+		offset += size;
+	}
+	return {
+		sizes,
+		offsets,
+		totalSize: offset
+	};
+};
+/** Lookup the start offset in px for item i (0-based). Out-of-range indexes return totalSize. */
+var axisOffset = (layout, index) => {
+	if (index < 0) return 0;
+	if (index >= layout.offsets.length) return layout.totalSize;
+	return layout.offsets[index];
+};
+/**
+* Inverse of axisOffset: the 0-based item containing the given px position, clamped to the layout.
+* Binary search over the prefix sums, returning the last item whose start offset is <= px, so a run of
+* zero-size (hidden) items resolves to the visible item after them.
+*/
+var axisIndexAt = (layout, px) => {
+	const last = layout.offsets.length - 1;
+	if (last < 0) return 0;
+	const position = Math.max(px, 0);
+	if (position >= layout.totalSize) return last;
+	let low = 0;
+	let high = last;
+	while (low < high) {
+		const mid = low + high + 1 >> 1;
+		if (layout.offsets[mid] <= position) low = mid;
+		else high = mid - 1;
+	}
+	return low;
+};
+/** Merged range (1-based inclusive) -> pixel rect, based on row/column AxisLayout. */
+var mergeRectPx = (merge, rowLayout, colLayout) => {
+	const x = axisOffset(colLayout, merge.left - 1);
+	const y = axisOffset(rowLayout, merge.top - 1);
+	const right = axisOffset(colLayout, merge.right);
+	const bottom = axisOffset(rowLayout, merge.bottom);
+	return {
+		x,
+		y,
+		width: right - x,
+		height: bottom - y
+	};
+};
+/**
+* Merged ranges intersecting the viewport, including master coordinates and pixel rects.
+* A range is returned even when its master cell has scrolled out, as long as the merged rect intersects the viewport.
+* This is why the merge layer must render independently instead of relying on cell virtualization.
+*/
+var mergesInView = (merges, viewport, rowLayout, colLayout) => {
+	const result = [];
+	for (const merge of merges) {
+		const rect = mergeRectPx(merge, rowLayout, colLayout);
+		if (!(rect.x < viewport.right && rect.x + rect.width > viewport.left && rect.y < viewport.bottom && rect.y + rect.height > viewport.top)) continue;
+		result.push({
+			merge,
+			masterRow: merge.top,
+			masterCol: merge.left,
+			rect
+		});
+	}
+	return result;
+};
+/**
+* Grows a selection rect until it fully contains every merged range it touches, matching Excel: a selection may
+* never cut a merged cell in half. Iterated to a fixpoint because growing can reach further merges; each round must
+* grow the rect, so the merge cap (MAX_MERGED_RANGES) bounds both the rounds and the work per round.
+* @param rect Normalized selection rect (top <= bottom, left <= right).
+*/
+var expandRangeToMerges = (rect, merges) => {
+	let { top, left, bottom, right } = rect;
+	let grown = true;
+	while (grown) {
+		grown = false;
+		for (const merge of merges) {
+			if (merge.top > bottom || merge.bottom < top || merge.left > right || merge.right < left) continue;
+			if (merge.top < top) {
+				top = merge.top;
+				grown = true;
+			}
+			if (merge.left < left) {
+				left = merge.left;
+				grown = true;
+			}
+			if (merge.bottom > bottom) {
+				bottom = merge.bottom;
+				grown = true;
+			}
+			if (merge.right > right) {
+				right = merge.right;
+				grown = true;
+			}
+		}
+	}
+	return {
+		top,
+		left,
+		bottom,
+		right
+	};
+};
+/** Cell range -> A1 notation ('B2:D8'), normalized to top-left:bottom-right. A single cell renders as 'B2'. */
+var rangeAddress = (rect) => {
+	const start = cellAddress(Math.min(rect.top, rect.bottom), Math.min(rect.left, rect.right));
+	const end = cellAddress(Math.max(rect.top, rect.bottom), Math.max(rect.left, rect.right));
+	return start === end ? start : `${start}:${end}`;
+};
+/** Excel default font size 11pt -> px at zoom=1. Matches the CellStyle.fontSizePx default. */
+var DEFAULT_FONT_SIZE_PX = ptToPx(11);
+/** Line-height multiplier for wrapped cell text. */
+var WRAP_LINE_HEIGHT = 1.3;
+/**
+* Number of full text lines a wrapped cell can fit in the given cell height, minimum 1.
+* Used with -webkit-line-clamp so a short row shows only complete lines instead of slicing the last line in half.
+*/
+var wrapClampLines = (cellHeightPx, fontSizePx) => Math.max(1, Math.floor(cellHeightPx / (fontSizePx * WRAP_LINE_HEIGHT)));
+//#endregion
+//#region src/plugins/spreadsheet/XlsxGrid.tsx
+var cornersToRect = (anchor, active) => ({
+	top: Math.min(anchor.row, active.row),
+	left: Math.min(anchor.col, active.col),
+	bottom: Math.max(anchor.row, active.row),
+	right: Math.max(anchor.col, active.col)
+});
+/** Rect equality by value: hover and selection are compared by their four coordinates, never by object identity. */
+var sameRect = (a, b) => a === b || a !== null && b !== null && a.top === b.top && a.left === b.left && a.bottom === b.bottom && a.right === b.right;
+/** A selection is one logical cell when it is 1x1, or when it is exactly the merged range holding its anchor. */
+var isSingleLogicalCell = (rect, anchorMerge) => {
+	if (rect.top === rect.bottom && rect.left === rect.right) return true;
+	return anchorMerge !== void 0 && rect.top === anchorMerge.top && rect.left === anchorMerge.left && rect.bottom === anchorMerge.bottom && rect.right === anchorMerge.right;
+};
+/** Baseline row/column header sizes in px at zoom=1. */
+var ROW_HEADER_WIDTH_PX = 44;
+var COL_HEADER_HEIGHT_PX = 22;
+/** Extra items rendered outside the virtualized viewport. */
+var OVERSCAN = 6;
+/** Blank rows/columns beyond the used range. Fill the viewport first, then leave a small scrollable blank area. */
+var EXTRA_ROWS = 20;
+var EXTRA_COLS = 5;
+/** Default grid line when no cell border is set. Follows the DESIGN.md border token. */
+var DEFAULT_GRID_LINE = "0.5px solid var(--border)";
+/** Maximum selected-cell overlay content width in px at zoom=1. Wider content wraps at this width. */
+var SELECTED_OVERLAY_MAX_WIDTH_PX = 480;
+/** Default cell alignment when CellStyle.hAlign is unset: numbers right, booleans/errors center, others left. */
+var defaultHAlign = (cell) => {
+	if (typeof cell.raw === "number") return "right";
+	if (typeof cell.raw === "boolean") return "center";
+	return "left";
+};
+var BORDER_STYLE_CSS = {
+	thin: "solid",
+	medium: "solid",
+	thick: "solid",
+	dashed: "dashed",
+	dotted: "dotted",
+	hair: "dotted",
+	double: "double"
+};
+var BORDER_WIDTH_PX = {
+	thin: 1,
+	hair: 1,
+	dashed: 1,
+	dotted: 1,
+	medium: 1.5,
+	thick: 2,
+	double: 3
+};
+var borderEdgeToCss = (edge) => edge ? `${BORDER_WIDTH_PX[edge.style]}px ${BORDER_STYLE_CSS[edge.style]} ${edge.color}` : void 0;
+var H_ALIGN_TO_JUSTIFY = {
+	left: "flex-start",
+	center: "center",
+	right: "flex-end",
+	justify: "stretch"
+};
+var V_ALIGN_TO_ITEMS = {
+	top: "flex-start",
+	middle: "center",
+	bottom: "flex-end"
+};
+/** CellStyle -> inline style in the zoom=1 coordinate space. Positioning and sizing are added by callers. */
+var cellStyleToCss = (style) => {
+	const css = { fontSize: style?.fontSizePx ?? DEFAULT_FONT_SIZE_PX };
+	if (!style) return css;
+	if (style.fontFamily) css.fontFamily = style.fontFamily;
+	if (style.bold) css.fontWeight = "bold";
+	if (style.italic) css.fontStyle = "italic";
+	if (style.underline && style.strike) css.textDecoration = "underline line-through";
+	else if (style.underline) css.textDecoration = "underline";
+	else if (style.strike) css.textDecoration = "line-through";
+	if (style.color) css.color = style.color;
+	if (style.bg) css.backgroundColor = style.bg;
+	if (style.hAlign) css.justifyContent = H_ALIGN_TO_JUSTIFY[style.hAlign];
+	if (style.vAlign) css.alignItems = V_ALIGN_TO_ITEMS[style.vAlign];
+	if (style.wrap) {
+		css.whiteSpace = "normal";
+		css.wordBreak = "break-word";
+	}
+	if (style.indent) css.paddingLeft = style.indent * 8;
+	const borderRight = borderEdgeToCss(style.borderRight);
+	const borderBottom = borderEdgeToCss(style.borderBottom);
+	const borderTop = borderEdgeToCss(style.borderTop);
+	const borderLeft = borderEdgeToCss(style.borderLeft);
+	if (borderRight) css.borderRight = borderRight;
+	if (borderBottom) css.borderBottom = borderBottom;
+	if (borderTop) css.borderTop = borderTop;
+	if (borderLeft) css.borderLeft = borderLeft;
+	return css;
+};
+/** Inline style for the cell text span: hyperlink coloring and whole-line clipping for wrapped cells. */
+var cellTextStyle = (cell, clampLines) => {
+	if (!cell.hyperlink && !clampLines) return void 0;
+	return {
+		...cell.hyperlink ? {
+			color: "var(--primary)",
+			textDecoration: "underline"
+		} : void 0,
+		...clampLines ? {
+			display: "-webkit-box",
+			WebkitBoxOrient: "vertical",
+			WebkitLineClamp: clampLines,
+			overflow: "hidden",
+			lineHeight: WRAP_LINE_HEIGHT
+		} : void 0
+	};
+};
+/** Shared renderer for regular and merged cells. Covered non-master cells pass cell=undefined and keep only background. */
+var CellView = memo(function CellView({ cell, style, covered = false, isFirstRow, isFirstCol, top, left, width, height }) {
+	const css = cellStyleToCss(style);
+	const hAlign = style?.hAlign ?? (cell ? defaultHAlign(cell) : "left");
+	const clampLines = style?.wrap ? wrapClampLines(height, css.fontSize) : void 0;
+	const finalCss = {
+		position: "absolute",
+		top,
+		left,
+		width,
+		height,
+		...css,
+		display: "flex",
+		justifyContent: css.justifyContent ?? H_ALIGN_TO_JUSTIFY[hAlign],
+		overflow: "hidden",
+		whiteSpace: css.whiteSpace ?? "nowrap",
+		boxSizing: "border-box",
+		borderRight: covered ? void 0 : css.borderRight ?? DEFAULT_GRID_LINE,
+		borderBottom: covered ? void 0 : css.borderBottom ?? DEFAULT_GRID_LINE,
+		borderTop: covered ? void 0 : isFirstRow ? css.borderTop ?? DEFAULT_GRID_LINE : css.borderTop,
+		borderLeft: covered ? void 0 : isFirstCol ? css.borderLeft ?? DEFAULT_GRID_LINE : css.borderLeft
+	};
+	return /* @__PURE__ */ jsx("div", {
+		className: "absolute px-1 text-foreground text-sm",
+		style: finalCss,
+		children: cell && /* @__PURE__ */ jsx("span", {
+			className: cn(cell.formulaState === "unevaluated" && "text-muted-foreground italic"),
+			style: cellTextStyle(cell, clampLines),
+			children: cell.text
+		})
+	});
+});
+/**
+* Selected-cell overlay. It renders full clipped content over the original cell without changing grid layout.
+*/
+var SelectedCellOverlay = ({ cell, style, rect }) => {
+	const css = cellStyleToCss(style);
+	const hAlign = style?.hAlign ?? (cell ? defaultHAlign(cell) : "left");
+	const finalCss = {
+		...css,
+		position: "absolute",
+		top: rect.y,
+		left: rect.x,
+		minWidth: rect.width,
+		minHeight: rect.height,
+		maxWidth: SELECTED_OVERLAY_MAX_WIDTH_PX,
+		width: "max-content",
+		display: "flex",
+		justifyContent: css.justifyContent ?? H_ALIGN_TO_JUSTIFY[hAlign],
+		whiteSpace: "pre-wrap",
+		wordBreak: "break-word",
+		lineHeight: WRAP_LINE_HEIGHT,
+		boxSizing: "border-box",
+		backgroundColor: css.backgroundColor ?? "var(--background)"
+	};
+	return /* @__PURE__ */ jsx("div", {
+		"data-testid": "xlsx-grid-selected-overlay",
+		className: "z-10 px-1 text-foreground text-sm shadow-md outline outline-primary",
+		style: finalCss,
+		children: cell && /* @__PURE__ */ jsx("span", {
+			className: cn(cell.formulaState === "unevaluated" && "text-muted-foreground italic"),
+			style: cellTextStyle(cell, void 0),
+			children: cell.text
+		})
+	});
+};
+/** Placeholder for unsupported charts: dashed border, centered label, and raw type name. */
+var UnsupportedChartPlaceholder = ({ chart }) => {
+	const { t } = useTranslation();
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex h-full w-full flex-col items-center justify-center gap-1 rounded-md border border-border border-dashed text-center text-muted-foreground text-xs",
+		children: [/* @__PURE__ */ jsx("span", { children: t("xlsx_preview.chart_unsupported") }), chart.rawTypeName && /* @__PURE__ */ jsx("span", { children: chart.rawTypeName })]
+	});
+};
+/** Chart mount host. The ref callback owns the disposer returned by renderChart and calls it on unmount/replacement. */
+var ChartHost = ({ chart, renderChart }) => {
+	const { t } = useTranslation();
+	const disposeRef = useRef(null);
+	const setRef = useCallback((node) => {
+		disposeRef.current?.();
+		disposeRef.current = node ? renderChart(chart, node) : null;
+	}, [chart, renderChart]);
+	return /* @__PURE__ */ jsx("div", {
+		ref: setRef,
+		className: "h-full w-full",
+		role: "img",
+		"aria-label": chart.title || t("xlsx_preview.chart")
+	});
+};
+/** True for a pointer target inside the floating layer (chart or image), which owns its own pointer interactions. */
+var isFloatingObject = (target) => target instanceof Element && target.closest("[data-xlsx-floating]") !== null;
+var XlsxGrid = ({ sheet, styles, imageUrls, zoom, onSelectCell, pickerActive, renderChart }) => {
+	const { options } = usePreviewHost();
+	const scrollElRef = useRef(null);
+	const [selected, setSelected] = useState(null);
+	/** Cell or merged range under the pointer while picking. Null whenever the picker is off. */
+	const [hoverRect, setHoverRect] = useState(null);
+	const selectionRef = useRef(null);
+	const dragRef = useRef(null);
+	const touchTapRef = useRef(null);
+	/** Last pointer client position while picking, so a scroll can re-resolve the hover with the pointer standing still. */
+	const lastPointerRef = useRef(null);
+	const suppressClickRef = useRef(false);
+	const pendingKeyCommitRef = useRef(false);
+	const [viewport, setViewport] = useState({
+		top: 0,
+		left: 0,
+		bottom: 0,
+		right: 0
+	});
+	const viewportHeight = viewport.bottom - viewport.top;
+	const viewportWidth = viewport.right - viewport.left;
+	const renderedRowCount = Math.max(sheet.rowCount, Math.ceil(viewportHeight / (sheet.defaultRowHeightPx * zoom))) + EXTRA_ROWS;
+	const renderedColCount = Math.max(sheet.colCount, Math.ceil(viewportWidth / (sheet.defaultColWidthPx * zoom))) + EXTRA_COLS;
+	const rowLayout = useMemo(() => buildAxisLayout(renderedRowCount, sheet.defaultRowHeightPx, sheet.rowHeightsPx, 1), [
+		renderedRowCount,
+		sheet.defaultRowHeightPx,
+		sheet.rowHeightsPx
+	]);
+	const colLayout = useMemo(() => buildAxisLayout(renderedColCount, sheet.defaultColWidthPx, sheet.colWidthsPx, 1), [
+		renderedColCount,
+		sheet.defaultColWidthPx,
+		sheet.colWidthsPx
+	]);
+	const scaledHeaderWidth = ROW_HEADER_WIDTH_PX * zoom;
+	const scaledHeaderHeight = COL_HEADER_HEIGHT_PX * zoom;
+	const zoomTransform = {
+		transform: `scale(${zoom})`,
+		transformOrigin: "top left"
+	};
+	const rowVirtualizer = useVirtualizer({
+		count: renderedRowCount,
+		getScrollElement: () => scrollElRef.current,
+		estimateSize: (index) => rowLayout.sizes[index] * zoom,
+		overscan: OVERSCAN
+	});
+	const colVirtualizer = useVirtualizer({
+		horizontal: true,
+		count: renderedColCount,
+		getScrollElement: () => scrollElRef.current,
+		estimateSize: (index) => colLayout.sizes[index] * zoom,
+		overscan: OVERSCAN
+	});
+	const virtualRows = rowVirtualizer.getVirtualItems();
+	const virtualCols = colVirtualizer.getVirtualItems();
+	const readViewport = useCallback((el) => ({
+		top: el.scrollTop,
+		left: el.scrollLeft,
+		bottom: el.scrollTop + el.clientHeight,
+		right: el.scrollLeft + el.clientWidth
+	}), []);
+	const scrollElCallback = useCallback((node) => {
+		scrollElRef.current = node;
+		if (node) setViewport(readViewport(node));
+	}, [readViewport]);
+	useEffect(() => {
+		const el = scrollElRef.current;
+		if (!el) return;
+		const observer = new ResizeObserver(() => setViewport(readViewport(el)));
+		observer.observe(el);
+		return () => observer.disconnect();
+	}, [readViewport]);
+	const contentViewport = useMemo(() => ({
+		top: viewport.top / zoom,
+		left: viewport.left / zoom,
+		bottom: viewport.bottom / zoom,
+		right: viewport.right / zoom
+	}), [viewport, zoom]);
+	const mergesVisible = useMemo(() => mergesInView(sheet.merges, contentViewport, rowLayout, colLayout), [
+		sheet.merges,
+		contentViewport,
+		rowLayout,
+		colLayout
+	]);
+	const mergeKeyStride = renderedColCount + 1;
+	const visibleMergeByCell = useMemo(() => {
+		const index = /* @__PURE__ */ new Map();
+		const firstRow = (virtualRows[0]?.index ?? 0) + 1;
+		const lastRow = (virtualRows[virtualRows.length - 1]?.index ?? -1) + 1;
+		const firstCol = (virtualCols[0]?.index ?? 0) + 1;
+		const lastCol = (virtualCols[virtualCols.length - 1]?.index ?? -1) + 1;
+		if (lastRow < firstRow || lastCol < firstCol) return index;
+		for (const { merge } of mergesVisible) {
+			const top = Math.max(merge.top, firstRow);
+			const bottom = Math.min(merge.bottom, lastRow);
+			const left = Math.max(merge.left, firstCol);
+			const right = Math.min(merge.right, lastCol);
+			for (let row = top; row <= bottom; row++) {
+				const rowKey = row * mergeKeyStride;
+				for (let col = left; col <= right; col++) index.set(rowKey + col, merge);
+			}
+		}
+		return index;
+	}, [
+		mergeKeyStride,
+		mergesVisible,
+		virtualCols,
+		virtualRows
+	]);
+	const getCell = useCallback((row, col) => sheet.cells[`${row}:${col}`], [sheet.cells]);
+	const getStyle = useCallback((cell) => cell?.styleId !== void 0 ? styles[cell.styleId] : void 0, [styles]);
+	/** Returns the merged range containing (row, col), if any. */
+	const findMerge = useCallback((row, col) => {
+		const visible = visibleMergeByCell.get(row * mergeKeyStride + col);
+		if (visible) return visible;
+		return sheet.merges.find((merge) => row >= merge.top && row <= merge.bottom && col >= merge.left && col <= merge.right);
+	}, [
+		mergeKeyStride,
+		sheet.merges,
+		visibleMergeByCell
+	]);
+	const applySelection = useCallback((next) => {
+		selectionRef.current = next;
+		setSelected(next);
+	}, []);
+	const commitSelection = useCallback((selection) => {
+		if (!selection) {
+			onSelectCell?.(null);
+			return;
+		}
+		const rect = expandRangeToMerges(cornersToRect(selection.anchor, selection.active), sheet.merges);
+		const single = isSingleLogicalCell(rect, findMerge(selection.anchor.row, selection.anchor.col));
+		onSelectCell?.({
+			range: single ? cellAddress(rect.top, rect.left) : rangeAddress(rect),
+			rect,
+			cell: single ? getCell(rect.top, rect.left) ?? null : null
+		});
+	}, [
+		findMerge,
+		getCell,
+		onSelectCell,
+		sheet.merges
+	]);
+	const selectCell = useCallback((row, col) => {
+		const merge = findMerge(row, col);
+		const cell = {
+			row: merge?.top ?? row,
+			col: merge?.left ?? col
+		};
+		const next = {
+			anchor: cell,
+			active: cell
+		};
+		applySelection(next);
+		commitSelection(next);
+	}, [
+		applySelection,
+		commitSelection,
+		findMerge
+	]);
+	const clearSelection = useCallback(() => {
+		dragRef.current = null;
+		pendingKeyCommitRef.current = false;
+		applySelection(null);
+		commitSelection(null);
+	}, [applySelection, commitSelection]);
+	const pickerWasActiveRef = useRef(false);
+	useEffect(() => {
+		const isActive = Boolean(pickerActive);
+		if (pickerWasActiveRef.current === isActive) return;
+		pickerWasActiveRef.current = isActive;
+		if (isActive) clearSelection();
+		else {
+			lastPointerRef.current = null;
+			setHoverRect(null);
+		}
+	}, [pickerActive, clearSelection]);
+	const moveSelection = useCallback((dRow, dCol) => {
+		if (!selected) {
+			selectCell(1, 1);
+			rowVirtualizer.scrollToIndex(0);
+			colVirtualizer.scrollToIndex(0);
+			return;
+		}
+		const from = selected.active;
+		const merge = findMerge(from.row, from.col);
+		let nextRow = from.row;
+		let nextCol = from.col;
+		if (dRow > 0) nextRow = (merge?.bottom ?? from.row) + 1;
+		else if (dRow < 0) nextRow = from.row - 1;
+		if (dCol > 0) nextCol = (merge?.right ?? from.col) + 1;
+		else if (dCol < 0) nextCol = from.col - 1;
+		nextRow = Math.min(Math.max(nextRow, 1), sheet.rowCount);
+		nextCol = Math.min(Math.max(nextCol, 1), sheet.colCount);
+		selectCell(nextRow, nextCol);
+		rowVirtualizer.scrollToIndex(nextRow - 1);
+		colVirtualizer.scrollToIndex(nextCol - 1);
+	}, [
+		selected,
+		findMerge,
+		sheet.rowCount,
+		sheet.colCount,
+		selectCell,
+		rowVirtualizer,
+		colVirtualizer
+	]);
+	const extendSelection = useCallback((dRow, dCol) => {
+		const current = selectionRef.current;
+		if (!current) {
+			selectCell(1, 1);
+			rowVirtualizer.scrollToIndex(0);
+			colVirtualizer.scrollToIndex(0);
+			return;
+		}
+		const active = {
+			row: Math.min(Math.max(current.active.row + dRow, 1), sheet.rowCount),
+			col: Math.min(Math.max(current.active.col + dCol, 1), sheet.colCount)
+		};
+		applySelection({
+			anchor: current.anchor,
+			active
+		});
+		pendingKeyCommitRef.current = true;
+		rowVirtualizer.scrollToIndex(active.row - 1);
+		colVirtualizer.scrollToIndex(active.col - 1);
+	}, [
+		applySelection,
+		colVirtualizer,
+		rowVirtualizer,
+		selectCell,
+		sheet.colCount,
+		sheet.rowCount
+	]);
+	const handleKeyDown = useCallback((e) => {
+		const step = e.shiftKey ? extendSelection : moveSelection;
+		switch (e.key) {
+			case "Escape":
+				clearSelection();
+				return;
+			case "ArrowUp":
+				e.preventDefault();
+				step(-1, 0);
+				return;
+			case "ArrowDown":
+				e.preventDefault();
+				step(1, 0);
+				return;
+			case "ArrowLeft":
+				e.preventDefault();
+				step(0, -1);
+				return;
+			case "ArrowRight":
+				e.preventDefault();
+				step(0, 1);
+				return;
+			case "Enter":
+			case " ": {
+				e.preventDefault();
+				const target = selected?.active ?? {
+					row: 1,
+					col: 1
+				};
+				selectCell(target.row, target.col);
+				rowVirtualizer.scrollToIndex(target.row - 1);
+				colVirtualizer.scrollToIndex(target.col - 1);
+				return;
+			}
+		}
+	}, [
+		clearSelection,
+		extendSelection,
+		moveSelection,
+		selected,
+		selectCell,
+		rowVirtualizer,
+		colVirtualizer
+	]);
+	const commitPendingKeySelection = useCallback(() => {
+		if (!pendingKeyCommitRef.current) return;
+		pendingKeyCommitRef.current = false;
+		commitSelection(selectionRef.current);
+	}, [commitSelection]);
+	/** Pointer position -> 1-based cell, plus whether the pointer is over the sticky row/column headers. */
+	const cellAtPointer = useCallback((clientX, clientY) => {
+		const el = scrollElRef.current;
+		if (!el) return null;
+		const bounds = el.getBoundingClientRect();
+		const offsetX = clientX - bounds.left;
+		const offsetY = clientY - bounds.top;
+		const x = (offsetX + el.scrollLeft - scaledHeaderWidth) / zoom;
+		const y = (offsetY + el.scrollTop - scaledHeaderHeight) / zoom;
+		return {
+			row: axisIndexAt(rowLayout, y) + 1,
+			col: axisIndexAt(colLayout, x) + 1,
+			inHeader: offsetX < scaledHeaderWidth || offsetY < scaledHeaderHeight
+		};
+	}, [
+		colLayout,
+		rowLayout,
+		scaledHeaderHeight,
+		scaledHeaderWidth,
+		zoom
+	]);
+	const selectionAtPointer = useCallback((clientX, clientY, extend) => {
+		const target = cellAtPointer(clientX, clientY);
+		if (!target || target.inHeader || target.row > sheet.rowCount || target.col > sheet.colCount) return null;
+		const merge = findMerge(target.row, target.col);
+		const cell = {
+			row: merge?.top ?? target.row,
+			col: merge?.left ?? target.col
+		};
+		const current = selectionRef.current;
+		return extend && current !== null ? {
+			anchor: current.anchor,
+			active: cell
+		} : {
+			anchor: cell,
+			active: cell
+		};
+	}, [
+		cellAtPointer,
+		findMerge,
+		sheet.colCount,
+		sheet.rowCount
+	]);
+	const handlePointerDown = useCallback((e) => {
+		suppressClickRef.current = false;
+		if (isFloatingObject(e.target)) return;
+		if (e.button !== 0) return;
+		if (e.pointerType === "touch") {
+			touchTapRef.current = e.pointerId;
+			return;
+		}
+		if (pickerActive) setHoverRect(null);
+		const next = selectionAtPointer(e.clientX, e.clientY, e.shiftKey);
+		if (!next) return;
+		applySelection(next);
+		dragRef.current = {
+			pointerId: e.pointerId,
+			selection: next
+		};
+		e.currentTarget.setPointerCapture?.(e.pointerId);
+	}, [
+		applySelection,
+		pickerActive,
+		selectionAtPointer
+	]);
+	const updateHoverRect = useCallback((next) => {
+		setHoverRect((current) => sameRect(current, next) ? current : next);
+	}, []);
+	const resolveHover = useCallback((clientX, clientY) => {
+		const hovered = cellAtPointer(clientX, clientY);
+		if (!hovered || hovered.inHeader || hovered.row > sheet.rowCount || hovered.col > sheet.colCount) {
+			updateHoverRect(null);
+			return;
+		}
+		const hoveredMerge = findMerge(hovered.row, hovered.col);
+		updateHoverRect(hoveredMerge ?? {
+			top: hovered.row,
+			left: hovered.col,
+			bottom: hovered.row,
+			right: hovered.col
+		});
+	}, [
+		cellAtPointer,
+		findMerge,
+		sheet.colCount,
+		sheet.rowCount,
+		updateHoverRect
+	]);
+	const handleScroll = useCallback((e) => {
+		setViewport(readViewport(e.currentTarget));
+		const last = lastPointerRef.current;
+		if (!pickerActive || dragRef.current || !last) return;
+		resolveHover(last.x, last.y);
+	}, [
+		pickerActive,
+		readViewport,
+		resolveHover
+	]);
+	const handlePointerMove = useCallback((e) => {
+		const drag = dragRef.current;
+		if (!drag) {
+			if (!pickerActive) return;
+			if (isFloatingObject(e.target)) {
+				lastPointerRef.current = null;
+				updateHoverRect(null);
+				return;
+			}
+			lastPointerRef.current = {
+				x: e.clientX,
+				y: e.clientY
+			};
+			resolveHover(e.clientX, e.clientY);
+			return;
+		}
+		if (drag.pointerId !== e.pointerId) return;
+		const target = cellAtPointer(e.clientX, e.clientY);
+		if (!target) return;
+		const clamped = {
+			row: Math.min(Math.max(target.row, 1), sheet.rowCount),
+			col: Math.min(Math.max(target.col, 1), sheet.colCount)
+		};
+		const merge = findMerge(clamped.row, clamped.col);
+		const active = {
+			row: merge?.top ?? clamped.row,
+			col: merge?.left ?? clamped.col
+		};
+		if (active.row === drag.selection.active.row && active.col === drag.selection.active.col) return;
+		const next = {
+			anchor: drag.selection.anchor,
+			active
+		};
+		dragRef.current = {
+			pointerId: drag.pointerId,
+			selection: next
+		};
+		applySelection(next);
+	}, [
+		applySelection,
+		cellAtPointer,
+		findMerge,
+		pickerActive,
+		resolveHover,
+		sheet.colCount,
+		sheet.rowCount,
+		updateHoverRect
+	]);
+	const handlePointerUp = useCallback((e) => {
+		if (touchTapRef.current === e.pointerId) {
+			touchTapRef.current = null;
+			const tapped = selectionAtPointer(e.clientX, e.clientY, false);
+			if (!tapped) return;
+			applySelection(tapped);
+			suppressClickRef.current = true;
+			commitSelection(tapped);
+			return;
+		}
+		const drag = dragRef.current;
+		if (!drag || drag.pointerId !== e.pointerId) return;
+		dragRef.current = null;
+		e.currentTarget.releasePointerCapture?.(e.pointerId);
+		suppressClickRef.current = true;
+		commitSelection(drag.selection);
+	}, [
+		applySelection,
+		commitSelection,
+		selectionAtPointer
+	]);
+	const handlePointerCancel = useCallback(() => {
+		touchTapRef.current = null;
+		const drag = dragRef.current;
+		if (!drag) return;
+		dragRef.current = null;
+		commitSelection(drag.selection);
+	}, [commitSelection]);
+	const handlePointerLeave = useCallback(() => {
+		lastPointerRef.current = null;
+		if (pickerActive) setHoverRect(null);
+	}, [pickerActive]);
+	const handleClickCapture = useCallback((e) => {
+		if (!suppressClickRef.current) return;
+		suppressClickRef.current = false;
+		e.stopPropagation();
+	}, []);
+	const selectionRect = useMemo(() => selected ? expandRangeToMerges(cornersToRect(selected.anchor, selected.active), sheet.merges) : null, [selected, sheet.merges]);
+	const anchorMerge = selected ? findMerge(selected.anchor.row, selected.anchor.col) : void 0;
+	const isSingleCellSelection = selectionRect !== null && isSingleLogicalCell(selectionRect, anchorMerge);
+	const selectionRectPx = useMemo(() => selectionRect ? mergeRectPx(selectionRect, rowLayout, colLayout) : null, [
+		selectionRect,
+		rowLayout,
+		colLayout
+	]);
+	const hoverRectPx = useMemo(() => hoverRect ? mergeRectPx(hoverRect, rowLayout, colLayout) : null, [
+		hoverRect,
+		rowLayout,
+		colLayout
+	]);
+	const hoverInsidePick = Boolean(hoverRect && selectionRect && hoverRect.top >= selectionRect.top && hoverRect.bottom <= selectionRect.bottom && hoverRect.left >= selectionRect.left && hoverRect.right <= selectionRect.right);
+	const opaqueHeaders = options?.xlsx?.opaqueHeaders === true;
+	const headerBackground = opaqueHeaders ? {
+		backgroundColor: "rgb(from var(--background) r g b / 1)",
+		backgroundImage: "linear-gradient(var(--muted), var(--muted))"
+	} : void 0;
+	const totalWidth = colLayout.totalSize * zoom + scaledHeaderWidth;
+	const totalHeight = rowLayout.totalSize * zoom + scaledHeaderHeight;
+	return /* @__PURE__ */ jsx("div", {
+		ref: scrollElCallback,
+		"data-testid": "xlsx-grid-scroll",
+		"data-picker": pickerActive ? "true" : void 0,
+		className: cn("relative h-full w-full overflow-auto bg-background", pickerActive && "cursor-cell"),
+		onScroll: handleScroll,
+		onKeyDown: handleKeyDown,
+		onKeyUp: commitPendingKeySelection,
+		onBlur: commitPendingKeySelection,
+		onPointerDown: handlePointerDown,
+		onPointerMove: handlePointerMove,
+		onPointerUp: handlePointerUp,
+		onPointerCancel: handlePointerCancel,
+		onPointerLeave: handlePointerLeave,
+		onClickCapture: handleClickCapture,
+		role: "grid",
+		"aria-label": sheet.name,
+		"aria-readonly": true,
+		"aria-multiselectable": true,
+		"aria-rowcount": sheet.rowCount,
+		"aria-colcount": sheet.colCount,
+		tabIndex: 0,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "relative",
+			style: {
+				width: totalWidth,
+				height: totalHeight
+			},
+			children: [
+				opaqueHeaders ? /* @__PURE__ */ jsx("div", {
+					"aria-hidden": true,
+					className: "sticky top-0 left-0 z-30 border-r border-b border-border",
+					style: {
+						...headerBackground,
+						width: scaledHeaderWidth,
+						height: scaledHeaderHeight,
+						marginBottom: -scaledHeaderHeight
+					}
+				}) : null,
+				/* @__PURE__ */ jsx("div", {
+					className: "sticky top-0 z-20 border-border border-b bg-muted",
+					style: {
+						...headerBackground,
+						height: scaledHeaderHeight,
+						marginLeft: scaledHeaderWidth,
+						width: colLayout.totalSize * zoom
+					},
+					children: /* @__PURE__ */ jsx("div", {
+						className: "absolute",
+						style: zoomTransform,
+						children: virtualCols.map((vc) => /* @__PURE__ */ jsx("div", {
+							className: "absolute flex items-center justify-center border-border border-r text-muted-foreground text-xs",
+							style: {
+								left: axisOffset(colLayout, vc.index),
+								width: colLayout.sizes[vc.index],
+								height: COL_HEADER_HEIGHT_PX
+							},
+							children: colName(vc.index + 1)
+						}, vc.key))
+					})
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: "sticky left-0 z-20 border-border border-r bg-muted",
+					style: {
+						...headerBackground,
+						width: scaledHeaderWidth,
+						height: rowLayout.totalSize * zoom,
+						top: scaledHeaderHeight
+					},
+					children: /* @__PURE__ */ jsx("div", {
+						className: "absolute",
+						style: zoomTransform,
+						children: virtualRows.map((vr) => /* @__PURE__ */ jsx("div", {
+							className: "absolute flex items-center justify-center border-border border-b text-muted-foreground text-xs",
+							style: {
+								top: axisOffset(rowLayout, vr.index),
+								height: rowLayout.sizes[vr.index],
+								width: ROW_HEADER_WIDTH_PX
+							},
+							children: vr.index + 1
+						}, vr.key))
+					})
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "absolute",
+					"data-testid": "xlsx-grid-zoom-layer",
+					style: {
+						top: scaledHeaderHeight,
+						left: scaledHeaderWidth,
+						...zoomTransform
+					},
+					children: [
+						/* @__PURE__ */ jsx("div", {
+							className: "absolute",
+							children: virtualRows.map((vr) => {
+								const row = vr.index + 1;
+								const isSemanticRow = row <= sheet.rowCount;
+								return /* @__PURE__ */ jsx("div", {
+									role: isSemanticRow ? "row" : void 0,
+									"aria-hidden": isSemanticRow ? void 0 : true,
+									"aria-rowindex": isSemanticRow ? row : void 0,
+									children: virtualCols.map((vc) => {
+										const col = vc.index + 1;
+										const isSemanticCell = isSemanticRow && col <= sheet.colCount;
+										const merge = visibleMergeByCell.get(row * mergeKeyStride + col);
+										const isMaster = merge !== void 0 && merge.top === row && merge.left === col;
+										const isCovered = merge !== void 0 && !isMaster;
+										const exposesGridCell = isSemanticCell && !isCovered;
+										const cell = merge ? void 0 : getCell(row, col);
+										const style = merge ? void 0 : getStyle(cell);
+										const isSelected = !isCovered && selectionRect !== null && row >= selectionRect.top && row <= selectionRect.bottom && col >= selectionRect.left && col <= selectionRect.right;
+										return /* @__PURE__ */ jsx("div", {
+											onClick: isSemanticCell ? () => selectCell(row, col) : void 0,
+											role: exposesGridCell ? "gridcell" : void 0,
+											"aria-hidden": exposesGridCell ? void 0 : true,
+											"aria-colindex": exposesGridCell ? col : void 0,
+											"aria-selected": exposesGridCell ? isSelected : void 0,
+											"aria-colspan": isMaster && exposesGridCell ? merge.right - merge.left + 1 : void 0,
+											"aria-rowspan": isMaster && exposesGridCell ? merge.bottom - merge.top + 1 : void 0,
+											"aria-label": isMaster && exposesGridCell ? getCell(row, col)?.text || void 0 : void 0,
+											children: /* @__PURE__ */ jsx(CellView, {
+												cell,
+												style,
+												covered: isCovered,
+												isFirstRow: row === 1,
+												isFirstCol: col === 1,
+												top: axisOffset(rowLayout, vr.index),
+												left: axisOffset(colLayout, vc.index),
+												width: colLayout.sizes[vc.index],
+												height: rowLayout.sizes[vr.index]
+											})
+										}, vc.key);
+									})
+								}, vr.key);
+							})
+						}),
+						/* @__PURE__ */ jsx("div", {
+							className: "absolute",
+							children: mergesVisible.map(({ merge, masterRow, masterCol, rect }) => {
+								const cell = getCell(masterRow, masterCol);
+								const style = getStyle(cell);
+								return /* @__PURE__ */ jsx("div", {
+									"aria-hidden": true,
+									onClick: () => selectCell(masterRow, masterCol),
+									children: /* @__PURE__ */ jsx("div", {
+										"data-testid": "xlsx-grid-merge-cell",
+										children: /* @__PURE__ */ jsx(CellView, {
+											cell,
+											style,
+											isFirstRow: masterRow === 1,
+											isFirstCol: masterCol === 1,
+											top: rect.y,
+											left: rect.x,
+											width: rect.width,
+											height: rect.height
+										})
+									})
+								}, `merge:${merge.top}:${merge.left}:${merge.bottom}:${merge.right}`);
+							})
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "pointer-events-none absolute",
+							"data-xlsx-floating": "",
+							children: [sheet.floatingImages.map((img, i) => {
+								const src = imageUrls[img.imageId];
+								if (!src) return null;
+								return /* @__PURE__ */ jsx("img", {
+									src,
+									alt: "",
+									"data-testid": "xlsx-grid-floating-image",
+									className: "pointer-events-auto absolute object-contain",
+									style: {
+										top: img.rect.y,
+										left: img.rect.x,
+										width: img.rect.width,
+										height: img.rect.height
+									}
+								}, `img:${img.imageId}:${i}`);
+							}), sheet.charts.map((chart, i) => {
+								const positionStyle = {
+									top: chart.rect.y,
+									left: chart.rect.x,
+									width: chart.rect.width,
+									height: chart.rect.height
+								};
+								return /* @__PURE__ */ jsx("div", {
+									className: "pointer-events-auto absolute",
+									style: positionStyle,
+									"data-testid": "xlsx-grid-chart",
+									children: chart.type === "unsupported" || !renderChart ? /* @__PURE__ */ jsx(UnsupportedChartPlaceholder, { chart }) : /* @__PURE__ */ jsx(ChartHost, {
+										chart,
+										renderChart
+									})
+								}, `chart:${i}`);
+							})]
+						}),
+						pickerActive && hoverRectPx && !hoverInsidePick && /* @__PURE__ */ jsx("div", {
+							"aria-hidden": true,
+							"data-testid": "xlsx-grid-hover-cell",
+							className: "pointer-events-none absolute bg-primary/5 outline-2 outline-primary/40",
+							style: {
+								top: hoverRectPx.y,
+								left: hoverRectPx.x,
+								width: hoverRectPx.width,
+								height: hoverRectPx.height
+							}
+						}),
+						selectionRect && selectionRectPx && (isSingleCellSelection ? /* @__PURE__ */ jsx(SelectedCellOverlay, {
+							cell: getCell(selectionRect.top, selectionRect.left),
+							style: getStyle(getCell(selectionRect.top, selectionRect.left)),
+							rect: selectionRectPx
+						}) : /* @__PURE__ */ jsx("div", {
+							"aria-hidden": true,
+							"data-testid": "xlsx-grid-selection-range",
+							className: "pointer-events-none absolute bg-primary/10 outline-2 outline-primary",
+							style: {
+								top: selectionRectPx.y,
+								left: selectionRectPx.x,
+								width: selectionRectPx.width,
+								height: selectionRectPx.height
+							}
+						}))
+					]
+				})
+			]
+		})
+	});
+};
+var XlsxGrid_default = memo(XlsxGrid);
+//#endregion
+//#region src/plugins/spreadsheet/SpreadsheetFilePreview.tsx
+/** Zoom levels. The default index is 2 (=1). */
+var ZOOM_LEVELS = [
+	.5,
+	.75,
+	1,
+	1.25,
+	1.5,
+	2
+];
+var DEFAULT_ZOOM = 1;
+var formatZoomLabel = (zoom) => `${Math.round(zoom * 100)}%`;
+/** Visible sheets from model.sheets. If all are hidden, fall back to the first sheet so one tab remains selectable. */
+var visibleSheets = (model) => {
+	const visible = model.sheets.filter((sheet) => !sheet.hidden);
+	if (visible.length > 0) return visible;
+	return model.sheets.slice(0, 1);
+};
+var chartRendererPromise = null;
+var loadChartRenderer = () => {
+	chartRendererPromise ??= import("./EchartsChartRenderer-e2b5JysX.js").then((module) => module.echartsChartRenderer).catch((error) => {
+		chartRendererPromise = null;
+		throw error;
+	});
+	return chartRendererPromise;
+};
+var sheetHasChart = (sheet) => Boolean(sheet && sheet.charts.length > 0);
+/**
+* Hard cap on cells visited while building a selection excerpt. sheet.cells is sparse but the rect is not, so a
+* whole-column selection would otherwise walk millions of empty coordinates on the main thread.
+*/
+var EXCERPT_MAX_SCAN_CELLS = 5e4;
+/**
+* Plain-text snapshot of a selected range: tab-separated cells, newline-separated rows.
+* Both budgets are checked while scanning — building the full text first and truncating afterwards is what makes a
+* full-column selection hang. createPreviewSelection does the exact normalization and truncation.
+*
+* Only text that survives normalization counts against the character budget, which is why each cell is charged its
+* normalized length rather than its raw one. A cell that leaves nothing behind — empty, or holding only whitespace,
+* the way an export that blanks a cell with a space leaves it — collapses away along with its separators, so
+* charging for it would let a run of them exhaust the budget and normalize down to an empty excerpt. The scan cap
+* stays separate — it is what bounds the walk over a sparse selection.
+*
+* ExcelJS reports a merged range's value through every cell it covers, so each range is emitted once, at its master.
+* Merges are swept row by row rather than searched per cell, keeping the walk linear in the scan cap.
+*/
+var buildRangeExcerpt = (sheet, rect) => {
+	const intersecting = sheet.merges.filter((m) => m.top <= rect.bottom && m.bottom >= rect.top && m.left <= rect.right && m.right >= rect.left).sort((a, b) => a.top - b.top);
+	const lines = [];
+	let length = 0;
+	let scanned = 0;
+	let nextMerge = 0;
+	let active = [];
+	for (let row = rect.top; row <= rect.bottom; row++) {
+		while (nextMerge < intersecting.length && intersecting[nextMerge].top <= row) active.push(intersecting[nextMerge++]);
+		if (active.length > 0) active = active.filter((merge) => merge.bottom >= row);
+		const values = [];
+		for (let col = rect.left; col <= rect.right; col++) {
+			if (scanned >= EXCERPT_MAX_SCAN_CELLS || length >= 2e3) break;
+			scanned++;
+			const covering = active.find((merge) => merge.left <= col && merge.right >= col);
+			const text = covering !== void 0 && (covering.top !== row || covering.left !== col) ? "" : sheet.cells[`${row}:${col}`]?.text ?? "";
+			values.push(text);
+			const charged = normalizeSelectionText(text).length;
+			if (charged > 0) length += charged + 1;
+		}
+		lines.push(values.join("	"));
+		if (scanned >= EXCERPT_MAX_SCAN_CELLS || length >= 2e3) break;
+	}
+	return lines.join("\n");
+};
+/** Read-only XLSX preview with virtualized sheets, formula status, images, and lazily loaded charts. */
+function SpreadsheetFilePreview({ sourceId, fileName, document: previewDocument, onSelection }) {
+	const logger = usePreviewLogger("SpreadsheetFilePreview");
+	const { options } = usePreviewHost();
+	const { t } = useTranslation();
+	const state = useXlsxWorkbook(previewDocument, fileName);
+	const [zoom, setZoom] = useState(DEFAULT_ZOOM);
+	const [activeSheetName, setActiveSheetName] = useState(null);
+	const [selectedCell, setSelectedCell] = useState(null);
+	const [chartRenderer, setChartRenderer] = useState(null);
+	const [imageUrls, setImageUrls] = useState({});
+	const model = state.status === "ready" ? state.model : null;
+	const sheets = useMemo(() => model ? visibleSheets(model) : [], [model]);
+	const activeSheet = sheets.find((sheet) => sheet.name === activeSheetName) ?? sheets[0] ?? null;
+	useEffect(() => {
+		setSelectedCell(null);
+		if (sheets.length === 0) {
+			setActiveSheetName(null);
+			return;
+		}
+		if (!sheets.some((sheet) => sheet.name === activeSheetName)) setActiveSheetName(sheets[0].name);
+	}, [sheets, activeSheetName]);
+	const handleSelectCell = useCallback((info) => setSelectedCell(info && activeSheet ? {
+		...info,
+		sheet: activeSheet
+	} : null), [activeSheet]);
+	const selectionReference = useMemo(() => {
+		if (!selectedCell || !activeSheet || selectedCell.sheet !== activeSheet) return null;
+		return createPreviewSelection({
+			sourceId,
+			anchor: {
+				format: "xlsx",
+				sheet: activeSheet.name,
+				range: selectedCell.range
+			},
+			excerpt: buildRangeExcerpt(activeSheet, selectedCell.rect),
+			revision: previewDocument.revision
+		});
+	}, [
+		selectedCell,
+		activeSheet,
+		sourceId,
+		previewDocument.revision
+	]);
+	const captureArmedRef = useRef(false);
+	useEffect(() => {
+		if (!onSelection) {
+			captureArmedRef.current = false;
+			return;
+		}
+		if (!captureArmedRef.current) {
+			captureArmedRef.current = true;
+			return;
+		}
+		onSelection(selectionReference);
+	}, [selectionReference, onSelection]);
+	useEffect(() => {
+		if (!model) return;
+		const nextUrls = {};
+		for (const [imageId, image] of Object.entries(model.images)) nextUrls[Number(imageId)] = URL.createObjectURL(new Blob([image.data], { type: image.mime }));
+		setImageUrls(nextUrls);
+		return () => {
+			for (const url of Object.values(nextUrls)) URL.revokeObjectURL(url);
+		};
+	}, [model]);
+	useEffect(() => {
+		if (chartRenderer || !sheets.some((sheet) => sheetHasChart(sheet))) return;
+		let cancelled = false;
+		loadChartRenderer().then((renderer) => {
+			if (!cancelled) setChartRenderer(renderer);
+		}).catch((error) => {
+			if (cancelled) return;
+			const normalized = error instanceof Error ? error : new Error(String(error));
+			logger.error("Failed to load xlsx chart renderer", normalized);
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		sheets,
+		chartRenderer,
+		logger
+	]);
+	const renderChart = useMemo(() => {
+		if (!chartRenderer) return void 0;
+		return (chart, container) => chartRenderer.render(chart, container);
+	}, [chartRenderer]);
+	const zoomIndex = ZOOM_LEVELS.indexOf(zoom);
+	const zoomOut = useCallback(() => {
+		setZoom((current) => {
+			const index = ZOOM_LEVELS.indexOf(current);
+			return index > 0 ? ZOOM_LEVELS[index - 1] : current;
+		});
+	}, []);
+	const zoomIn = useCallback(() => {
+		setZoom((current) => {
+			const index = ZOOM_LEVELS.indexOf(current);
+			return index >= 0 && index < ZOOM_LEVELS.length - 1 ? ZOOM_LEVELS[index + 1] : current;
+		});
+	}, []);
+	let content;
+	if (state.status === "loading" || state.status === "idle") content = /* @__PURE__ */ jsxs("div", {
+		role: "status",
+		className: "flex h-full w-full items-center justify-center gap-2 bg-background text-muted-foreground text-sm",
+		children: [/* @__PURE__ */ jsx(LoaderCircle, {
+			className: "size-4 animate-spin",
+			"aria-hidden": true
+		}), /* @__PURE__ */ jsx("span", { children: t("file_preview.loading") })]
+	});
+	else if (state.status === "error") content = /* @__PURE__ */ jsx(EmptyState, {
+		icon: CircleAlert,
+		title: t("file_preview.load_error.title"),
+		description: t("xlsx_preview.error.description"),
+		className: "h-full"
+	});
+	else if (state.status === "oversize") content = /* @__PURE__ */ jsx(FilePreviewTooLarge, {
+		sizeBytes: state.sizeBytes,
+		limitBytes: XLSX_PREVIEW_MAX_SIZE_BYTES
+	});
+	else if (!model || !activeSheet) content = null;
+	else {
+		const cellOnActiveSheet = selectedCell && selectedCell.sheet === activeSheet ? selectedCell : null;
+		const selectedCellContent = cellOnActiveSheet?.cell?.formula ? `= ${cellOnActiveSheet.cell.formula}` : cellOnActiveSheet?.cell?.text;
+		const statusBarText = cellOnActiveSheet ? selectedCellContent ? `${cellOnActiveSheet.range}  ${selectedCellContent}` : cellOnActiveSheet.range : null;
+		content = /* @__PURE__ */ jsxs("div", {
+			"data-testid": "spreadsheet-file-preview",
+			role: "region",
+			"aria-label": fileName,
+			className: "relative flex h-full w-full flex-col overflow-hidden bg-background",
+			children: [/* @__PURE__ */ jsx("div", {
+				className: "min-h-0 flex-1",
+				children: /* @__PURE__ */ jsx(XlsxGrid_default, {
+					sheet: activeSheet,
+					styles: model.styles,
+					imageUrls,
+					zoom,
+					onSelectCell: handleSelectCell,
+					pickerActive: onSelection !== void 0,
+					renderChart
+				}, activeSheet.name)
+			}), /* @__PURE__ */ jsxs("div", {
+				"data-testid": "xlsx-preview-footer",
+				className: "flex shrink-0 items-center gap-2 border-border-subtle border-t bg-background px-2 py-1",
+				style: options?.bottomInset === "content" ? { paddingBottom: "calc(0.25rem + var(--file-preview-bottom-inset, 0px))" } : void 0,
+				children: [
+					/* @__PURE__ */ jsx(Tabs, {
+						value: activeSheet.name,
+						onValueChange: setActiveSheetName,
+						variant: "line",
+						className: "min-w-0 shrink",
+						children: /* @__PURE__ */ jsx(TabsList, {
+							"aria-label": t("xlsx_preview.sheet_tabs_label"),
+							className: "min-w-0 gap-1 overflow-x-auto",
+							children: sheets.map((sheet) => /* @__PURE__ */ jsx(TabsTrigger, {
+								value: sheet.name,
+								className: "shrink-0 px-2 py-1 text-xs",
+								children: sheet.name
+							}, sheet.name))
+						})
+					}),
+					/* @__PURE__ */ jsxs("div", {
+						className: "flex min-w-0 flex-1 items-center justify-end gap-2 text-muted-foreground text-xs",
+						children: [statusBarText ? /* @__PURE__ */ jsx("span", {
+							className: "selectable cursor-text select-text truncate",
+							"data-testid": "xlsx-preview-status-bar",
+							children: statusBarText
+						}) : null, cellOnActiveSheet?.cell?.formulaState === "unevaluated" ? /* @__PURE__ */ jsx("span", {
+							className: "shrink-0 italic",
+							children: t("xlsx_preview.formula_not_evaluated")
+						}) : null]
+					}),
+					/* @__PURE__ */ jsx(SpreadsheetFilePreviewToolbar, {
+						zoomLabel: formatZoomLabel(zoom),
+						canZoomOut: zoomIndex > 0,
+						canZoomIn: zoomIndex >= 0 && zoomIndex < ZOOM_LEVELS.length - 1,
+						onZoomOut: zoomOut,
+						onZoomIn: zoomIn
+					})
+				]
+			})]
+		});
+	}
+	return /* @__PURE__ */ jsx(FilePreviewLayout.Frame, { children: /* @__PURE__ */ jsx(FilePreviewLayout.Content, {
+		scrollsInternally: true,
+		children: content
+	}) });
+}
+//#endregion
+export { SpreadsheetFilePreview as default };