@alivault/pico 0.1.0

package/.output/server/_libs/dnd-kit__accessibility.mjs

@@ -0,0 +1,46 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { X as require_react } from "./@base-ui/react+[...].mjs";
+//#region node_modules/.pnpm/@dnd-kit+accessibility@3.1.1_react@19.2.5/node_modules/@dnd-kit/accessibility/dist/accessibility.esm.js
+var import_react = /* @__PURE__ */ __toESM(require_react());
+var hiddenStyles = { display: "none" };
+function HiddenText(_ref) {
+	let { id, value } = _ref;
+	return import_react.createElement("div", {
+		id,
+		style: hiddenStyles
+	}, value);
+}
+function LiveRegion(_ref) {
+	let { id, announcement, ariaLiveType = "assertive" } = _ref;
+	return import_react.createElement("div", {
+		id,
+		style: {
+			position: "fixed",
+			top: 0,
+			left: 0,
+			width: 1,
+			height: 1,
+			margin: -1,
+			border: 0,
+			padding: 0,
+			overflow: "hidden",
+			clip: "rect(0 0 0 0)",
+			clipPath: "inset(100%)",
+			whiteSpace: "nowrap"
+		},
+		role: "status",
+		"aria-live": ariaLiveType,
+		"aria-atomic": true
+	}, announcement);
+}
+function useAnnouncement() {
+	const [announcement, setAnnouncement] = (0, import_react.useState)("");
+	return {
+		announce: (0, import_react.useCallback)((value) => {
+			if (value != null) setAnnouncement(value);
+		}, []),
+		announcement
+	};
+}
+//#endregion
+export { LiveRegion as n, useAnnouncement as r, HiddenText as t };

package/.output/server/_libs/dnd-kit__sortable.mjs

@@ -0,0 +1,400 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { X as require_react } from "./@base-ui/react+[...].mjs";
+import { c as useDraggable, f as CSS, g as useUniqueId, h as useIsomorphicLayoutEffect, l as useDroppable, m as useCombinedRefs, o as getClientRect, p as isKeyboardEvent, r as KeyboardCode, s as useDndContext } from "./@dnd-kit/core+[...].mjs";
+//#region node_modules/.pnpm/@dnd-kit+sortable@10.0.0_@dnd-kit+core@6.3.1_react-dom@19.2.5_react@19.2.5__react@19.2.5__react@19.2.5/node_modules/@dnd-kit/sortable/dist/sortable.esm.js
+var import_react = /* @__PURE__ */ __toESM(require_react());
+/**
+* Move an array item to a different position. Returns a new array with the item moved to the new position.
+*/
+function arrayMove(array, from, to) {
+	const newArray = array.slice();
+	newArray.splice(to < 0 ? newArray.length + to : to, 0, newArray.splice(from, 1)[0]);
+	return newArray;
+}
+function getSortedRects(items, rects) {
+	return items.reduce((accumulator, id, index) => {
+		const rect = rects.get(id);
+		if (rect) accumulator[index] = rect;
+		return accumulator;
+	}, Array(items.length));
+}
+function isValidIndex(index) {
+	return index !== null && index >= 0;
+}
+function itemsEqual(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function normalizeDisabled(disabled) {
+	if (typeof disabled === "boolean") return {
+		draggable: disabled,
+		droppable: disabled
+	};
+	return disabled;
+}
+var defaultScale = {
+	scaleX: 1,
+	scaleY: 1
+};
+var horizontalListSortingStrategy = (_ref) => {
+	var _rects$activeIndex;
+	let { rects, activeNodeRect: fallbackActiveRect, activeIndex, overIndex, index } = _ref;
+	const activeNodeRect = (_rects$activeIndex = rects[activeIndex]) != null ? _rects$activeIndex : fallbackActiveRect;
+	if (!activeNodeRect) return null;
+	const itemGap = getItemGap(rects, index, activeIndex);
+	if (index === activeIndex) {
+		const newIndexRect = rects[overIndex];
+		if (!newIndexRect) return null;
+		return {
+			x: activeIndex < overIndex ? newIndexRect.left + newIndexRect.width - (activeNodeRect.left + activeNodeRect.width) : newIndexRect.left - activeNodeRect.left,
+			y: 0,
+			...defaultScale
+		};
+	}
+	if (index > activeIndex && index <= overIndex) return {
+		x: -activeNodeRect.width - itemGap,
+		y: 0,
+		...defaultScale
+	};
+	if (index < activeIndex && index >= overIndex) return {
+		x: activeNodeRect.width + itemGap,
+		y: 0,
+		...defaultScale
+	};
+	return {
+		x: 0,
+		y: 0,
+		...defaultScale
+	};
+};
+function getItemGap(rects, index, activeIndex) {
+	const currentRect = rects[index];
+	const previousRect = rects[index - 1];
+	const nextRect = rects[index + 1];
+	if (!currentRect || !previousRect && !nextRect) return 0;
+	if (activeIndex < index) return previousRect ? currentRect.left - (previousRect.left + previousRect.width) : nextRect.left - (currentRect.left + currentRect.width);
+	return nextRect ? nextRect.left - (currentRect.left + currentRect.width) : currentRect.left - (previousRect.left + previousRect.width);
+}
+var rectSortingStrategy = (_ref) => {
+	let { rects, activeIndex, overIndex, index } = _ref;
+	const newRects = arrayMove(rects, overIndex, activeIndex);
+	const oldRect = rects[index];
+	const newRect = newRects[index];
+	if (!newRect || !oldRect) return null;
+	return {
+		x: newRect.left - oldRect.left,
+		y: newRect.top - oldRect.top,
+		scaleX: newRect.width / oldRect.width,
+		scaleY: newRect.height / oldRect.height
+	};
+};
+var defaultScale$1 = {
+	scaleX: 1,
+	scaleY: 1
+};
+var verticalListSortingStrategy = (_ref) => {
+	var _rects$activeIndex;
+	let { activeIndex, activeNodeRect: fallbackActiveRect, index, rects, overIndex } = _ref;
+	const activeNodeRect = (_rects$activeIndex = rects[activeIndex]) != null ? _rects$activeIndex : fallbackActiveRect;
+	if (!activeNodeRect) return null;
+	if (index === activeIndex) {
+		const overIndexRect = rects[overIndex];
+		if (!overIndexRect) return null;
+		return {
+			x: 0,
+			y: activeIndex < overIndex ? overIndexRect.top + overIndexRect.height - (activeNodeRect.top + activeNodeRect.height) : overIndexRect.top - activeNodeRect.top,
+			...defaultScale$1
+		};
+	}
+	const itemGap = getItemGap$1(rects, index, activeIndex);
+	if (index > activeIndex && index <= overIndex) return {
+		x: 0,
+		y: -activeNodeRect.height - itemGap,
+		...defaultScale$1
+	};
+	if (index < activeIndex && index >= overIndex) return {
+		x: 0,
+		y: activeNodeRect.height + itemGap,
+		...defaultScale$1
+	};
+	return {
+		x: 0,
+		y: 0,
+		...defaultScale$1
+	};
+};
+function getItemGap$1(clientRects, index, activeIndex) {
+	const currentRect = clientRects[index];
+	const previousRect = clientRects[index - 1];
+	const nextRect = clientRects[index + 1];
+	if (!currentRect) return 0;
+	if (activeIndex < index) return previousRect ? currentRect.top - (previousRect.top + previousRect.height) : nextRect ? nextRect.top - (currentRect.top + currentRect.height) : 0;
+	return nextRect ? nextRect.top - (currentRect.top + currentRect.height) : previousRect ? currentRect.top - (previousRect.top + previousRect.height) : 0;
+}
+var ID_PREFIX = "Sortable";
+var Context = /* @__PURE__ */ import_react.createContext({
+	activeIndex: -1,
+	containerId: ID_PREFIX,
+	disableTransforms: false,
+	items: [],
+	overIndex: -1,
+	useDragOverlay: false,
+	sortedRects: [],
+	strategy: rectSortingStrategy,
+	disabled: {
+		draggable: false,
+		droppable: false
+	}
+});
+function SortableContext(_ref) {
+	let { children, id, items: userDefinedItems, strategy = rectSortingStrategy, disabled: disabledProp = false } = _ref;
+	const { active, dragOverlay, droppableRects, over, measureDroppableContainers } = useDndContext();
+	const containerId = useUniqueId(ID_PREFIX, id);
+	const useDragOverlay = Boolean(dragOverlay.rect !== null);
+	const items = (0, import_react.useMemo)(() => userDefinedItems.map((item) => typeof item === "object" && "id" in item ? item.id : item), [userDefinedItems]);
+	const isDragging = active != null;
+	const activeIndex = active ? items.indexOf(active.id) : -1;
+	const overIndex = over ? items.indexOf(over.id) : -1;
+	const previousItemsRef = (0, import_react.useRef)(items);
+	const itemsHaveChanged = !itemsEqual(items, previousItemsRef.current);
+	const disableTransforms = overIndex !== -1 && activeIndex === -1 || itemsHaveChanged;
+	const disabled = normalizeDisabled(disabledProp);
+	useIsomorphicLayoutEffect(() => {
+		if (itemsHaveChanged && isDragging) measureDroppableContainers(items);
+	}, [
+		itemsHaveChanged,
+		items,
+		isDragging,
+		measureDroppableContainers
+	]);
+	(0, import_react.useEffect)(() => {
+		previousItemsRef.current = items;
+	}, [items]);
+	const contextValue = (0, import_react.useMemo)(() => ({
+		activeIndex,
+		containerId,
+		disabled,
+		disableTransforms,
+		items,
+		overIndex,
+		useDragOverlay,
+		sortedRects: getSortedRects(items, droppableRects),
+		strategy
+	}), [
+		activeIndex,
+		containerId,
+		disabled.draggable,
+		disabled.droppable,
+		disableTransforms,
+		items,
+		overIndex,
+		droppableRects,
+		useDragOverlay,
+		strategy
+	]);
+	return import_react.createElement(Context.Provider, { value: contextValue }, children);
+}
+var defaultNewIndexGetter = (_ref) => {
+	let { id, items, activeIndex, overIndex } = _ref;
+	return arrayMove(items, activeIndex, overIndex).indexOf(id);
+};
+var defaultAnimateLayoutChanges = (_ref2) => {
+	let { containerId, isSorting, wasDragging, index, items, newIndex, previousItems, previousContainerId, transition } = _ref2;
+	if (!transition || !wasDragging) return false;
+	if (previousItems !== items && index === newIndex) return false;
+	if (isSorting) return true;
+	return newIndex !== index && containerId === previousContainerId;
+};
+var defaultTransition = {
+	duration: 200,
+	easing: "ease"
+};
+var transitionProperty = "transform";
+var disabledTransition = /* @__PURE__ */ CSS.Transition.toString({
+	property: transitionProperty,
+	duration: 0,
+	easing: "linear"
+});
+var defaultAttributes = { roleDescription: "sortable" };
+function useDerivedTransform(_ref) {
+	let { disabled, index, node, rect } = _ref;
+	const [derivedTransform, setDerivedtransform] = (0, import_react.useState)(null);
+	const previousIndex = (0, import_react.useRef)(index);
+	useIsomorphicLayoutEffect(() => {
+		if (!disabled && index !== previousIndex.current && node.current) {
+			const initial = rect.current;
+			if (initial) {
+				const current = getClientRect(node.current, { ignoreTransform: true });
+				const delta = {
+					x: initial.left - current.left,
+					y: initial.top - current.top,
+					scaleX: initial.width / current.width,
+					scaleY: initial.height / current.height
+				};
+				if (delta.x || delta.y) setDerivedtransform(delta);
+			}
+		}
+		if (index !== previousIndex.current) previousIndex.current = index;
+	}, [
+		disabled,
+		index,
+		node,
+		rect
+	]);
+	(0, import_react.useEffect)(() => {
+		if (derivedTransform) setDerivedtransform(null);
+	}, [derivedTransform]);
+	return derivedTransform;
+}
+function useSortable(_ref) {
+	let { animateLayoutChanges = defaultAnimateLayoutChanges, attributes: userDefinedAttributes, disabled: localDisabled, data: customData, getNewIndex = defaultNewIndexGetter, id, strategy: localStrategy, resizeObserverConfig, transition = defaultTransition } = _ref;
+	const { items, containerId, activeIndex, disabled: globalDisabled, disableTransforms, sortedRects, overIndex, useDragOverlay, strategy: globalStrategy } = (0, import_react.useContext)(Context);
+	const disabled = normalizeLocalDisabled(localDisabled, globalDisabled);
+	const index = items.indexOf(id);
+	const data = (0, import_react.useMemo)(() => ({
+		sortable: {
+			containerId,
+			index,
+			items
+		},
+		...customData
+	}), [
+		containerId,
+		customData,
+		index,
+		items
+	]);
+	const itemsAfterCurrentSortable = (0, import_react.useMemo)(() => items.slice(items.indexOf(id)), [items, id]);
+	const { rect, node, isOver, setNodeRef: setDroppableNodeRef } = useDroppable({
+		id,
+		data,
+		disabled: disabled.droppable,
+		resizeObserverConfig: {
+			updateMeasurementsFor: itemsAfterCurrentSortable,
+			...resizeObserverConfig
+		}
+	});
+	const { active, activatorEvent, activeNodeRect, attributes, setNodeRef: setDraggableNodeRef, listeners, isDragging, over, setActivatorNodeRef, transform } = useDraggable({
+		id,
+		data,
+		attributes: {
+			...defaultAttributes,
+			...userDefinedAttributes
+		},
+		disabled: disabled.draggable
+	});
+	const setNodeRef = useCombinedRefs(setDroppableNodeRef, setDraggableNodeRef);
+	const isSorting = Boolean(active);
+	const displaceItem = isSorting && !disableTransforms && isValidIndex(activeIndex) && isValidIndex(overIndex);
+	const shouldDisplaceDragSource = !useDragOverlay && isDragging;
+	const dragSourceDisplacement = shouldDisplaceDragSource && displaceItem ? transform : null;
+	const finalTransform = displaceItem ? dragSourceDisplacement != null ? dragSourceDisplacement : (localStrategy != null ? localStrategy : globalStrategy)({
+		rects: sortedRects,
+		activeNodeRect,
+		activeIndex,
+		overIndex,
+		index
+	}) : null;
+	const newIndex = isValidIndex(activeIndex) && isValidIndex(overIndex) ? getNewIndex({
+		id,
+		items,
+		activeIndex,
+		overIndex
+	}) : index;
+	const activeId = active == null ? void 0 : active.id;
+	const previous = (0, import_react.useRef)({
+		activeId,
+		items,
+		newIndex,
+		containerId
+	});
+	const itemsHaveChanged = items !== previous.current.items;
+	const shouldAnimateLayoutChanges = animateLayoutChanges({
+		active,
+		containerId,
+		isDragging,
+		isSorting,
+		id,
+		index,
+		items,
+		newIndex: previous.current.newIndex,
+		previousItems: previous.current.items,
+		previousContainerId: previous.current.containerId,
+		transition,
+		wasDragging: previous.current.activeId != null
+	});
+	const derivedTransform = useDerivedTransform({
+		disabled: !shouldAnimateLayoutChanges,
+		index,
+		node,
+		rect
+	});
+	(0, import_react.useEffect)(() => {
+		if (isSorting && previous.current.newIndex !== newIndex) previous.current.newIndex = newIndex;
+		if (containerId !== previous.current.containerId) previous.current.containerId = containerId;
+		if (items !== previous.current.items) previous.current.items = items;
+	}, [
+		isSorting,
+		newIndex,
+		containerId,
+		items
+	]);
+	(0, import_react.useEffect)(() => {
+		if (activeId === previous.current.activeId) return;
+		if (activeId != null && previous.current.activeId == null) {
+			previous.current.activeId = activeId;
+			return;
+		}
+		const timeoutId = setTimeout(() => {
+			previous.current.activeId = activeId;
+		}, 50);
+		return () => clearTimeout(timeoutId);
+	}, [activeId]);
+	return {
+		active,
+		activeIndex,
+		attributes,
+		data,
+		rect,
+		index,
+		newIndex,
+		items,
+		isOver,
+		isSorting,
+		isDragging,
+		listeners,
+		node,
+		overIndex,
+		over,
+		setNodeRef,
+		setActivatorNodeRef,
+		setDroppableNodeRef,
+		setDraggableNodeRef,
+		transform: derivedTransform != null ? derivedTransform : finalTransform,
+		transition: getTransition()
+	};
+	function getTransition() {
+		if (derivedTransform || itemsHaveChanged && previous.current.newIndex === index) return disabledTransition;
+		if (shouldDisplaceDragSource && !isKeyboardEvent(activatorEvent) || !transition) return;
+		if (isSorting || shouldAnimateLayoutChanges) return CSS.Transition.toString({
+			...transition,
+			property: transitionProperty
+		});
+	}
+}
+function normalizeLocalDisabled(localDisabled, globalDisabled) {
+	var _localDisabled$dragga, _localDisabled$droppa;
+	if (typeof localDisabled === "boolean") return {
+		draggable: localDisabled,
+		droppable: false
+	};
+	return {
+		draggable: (_localDisabled$dragga = localDisabled == null ? void 0 : localDisabled.draggable) != null ? _localDisabled$dragga : globalDisabled.draggable,
+		droppable: (_localDisabled$droppa = localDisabled == null ? void 0 : localDisabled.droppable) != null ? _localDisabled$droppa : globalDisabled.droppable
+	};
+}
+KeyboardCode.Down, KeyboardCode.Right, KeyboardCode.Up, KeyboardCode.Left;
+//#endregion
+export { verticalListSortingStrategy as a, useSortable as i, arrayMove as n, horizontalListSortingStrategy as r, SortableContext as t };

package/.output/server/_libs/escape-string-regexp.mjs

@@ -0,0 +1,7 @@
+//#region node_modules/.pnpm/escape-string-regexp@5.0.0/node_modules/escape-string-regexp/index.js
+function escapeStringRegexp(string) {
+	if (typeof string !== "string") throw new TypeError("Expected a string");
+	return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+//#endregion
+export { escapeStringRegexp as t };

package/.output/server/_libs/estree-util-is-identifier-name.mjs

@@ -0,0 +1,20 @@
+//#region node_modules/.pnpm/estree-util-is-identifier-name@3.0.0/node_modules/estree-util-is-identifier-name/lib/index.js
+var nameRe = /^[$_\p{ID_Start}][$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
+var nameReJsx = /^[$_\p{ID_Start}][-$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
+/** @type {Options} */
+var emptyOptions = {};
+/**
+* Checks if the given value is a valid identifier name.
+*
+* @param {string} name
+*   Identifier to check.
+* @param {Options | null | undefined} [options]
+*   Configuration (optional).
+* @returns {boolean}
+*   Whether `name` can be an identifier.
+*/
+function name(name, options) {
+	return ((options || emptyOptions).jsx ? nameReJsx : nameRe).test(name);
+}
+//#endregion
+export { name as t };

package/.output/server/_libs/extend.mjs

@@ -0,0 +1,75 @@
+import { t as __commonJSMin } from "../_runtime.mjs";
+//#region node_modules/.pnpm/extend@3.0.2/node_modules/extend/index.js
+var require_extend = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hasOwn = Object.prototype.hasOwnProperty;
+	var toStr = Object.prototype.toString;
+	var defineProperty = Object.defineProperty;
+	var gOPD = Object.getOwnPropertyDescriptor;
+	var isArray = function isArray(arr) {
+		if (typeof Array.isArray === "function") return Array.isArray(arr);
+		return toStr.call(arr) === "[object Array]";
+	};
+	var isPlainObject = function isPlainObject(obj) {
+		if (!obj || toStr.call(obj) !== "[object Object]") return false;
+		var hasOwnConstructor = hasOwn.call(obj, "constructor");
+		var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf");
+		if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) return false;
+		var key;
+		for (key in obj);
+		return typeof key === "undefined" || hasOwn.call(obj, key);
+	};
+	var setProperty = function setProperty(target, options) {
+		if (defineProperty && options.name === "__proto__") defineProperty(target, options.name, {
+			enumerable: true,
+			configurable: true,
+			value: options.newValue,
+			writable: true
+		});
+		else target[options.name] = options.newValue;
+	};
+	var getProperty = function getProperty(obj, name) {
+		if (name === "__proto__") {
+			if (!hasOwn.call(obj, name)) return;
+			else if (gOPD) return gOPD(obj, name).value;
+		}
+		return obj[name];
+	};
+	module.exports = function extend() {
+		var options, name, src, copy, copyIsArray, clone;
+		var target = arguments[0];
+		var i = 1;
+		var length = arguments.length;
+		var deep = false;
+		if (typeof target === "boolean") {
+			deep = target;
+			target = arguments[1] || {};
+			i = 2;
+		}
+		if (target == null || typeof target !== "object" && typeof target !== "function") target = {};
+		for (; i < length; ++i) {
+			options = arguments[i];
+			if (options != null) for (name in options) {
+				src = getProperty(target, name);
+				copy = getProperty(options, name);
+				if (target !== copy) {
+					if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
+						if (copyIsArray) {
+							copyIsArray = false;
+							clone = src && isArray(src) ? src : [];
+						} else clone = src && isPlainObject(src) ? src : {};
+						setProperty(target, {
+							name,
+							newValue: extend(deep, clone, copy)
+						});
+					} else if (typeof copy !== "undefined") setProperty(target, {
+						name,
+						newValue: copy
+					});
+				}
+			}
+		}
+		return target;
+	};
+}));
+//#endregion
+export { require_extend as t };