@iconoma/cli 0.0.1-beta.2 → 0.0.2

package/dist/studio/876.index.js

@@ -1,3848 +0,0 @@
-export const id = 876;
-export const ids = [876];
-export const modules = {
-
-/***/ 2876:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-var react__WEBPACK_IMPORTED_MODULE_0___namespace_cache;
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   render: () => (/* binding */ render)
-/* harmony export */ });
-/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(236);
-/* harmony import */ var react_dom_server__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8150);
-/* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(32);
-/* harmony import */ var react_dom__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5);
-
-
-
-
-
-
-var ThemeProviderContext = (0,react__WEBPACK_IMPORTED_MODULE_0__.createContext)({
-	theme: "system",
-	setTheme: () => null
-});
-function ThemeProvider({ children, defaultTheme = "system", storageKey = "iconoma-studio-theme", ...props }) {
-	const [theme, setTheme] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(() => (typeof window !== "undefined" ? localStorage.getItem(storageKey) : defaultTheme) || defaultTheme);
-	(0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
-		const root = window.document.documentElement;
-		root.classList.remove("light", "dark");
-		if (theme === "system") {
-			const systemTheme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
-			root.classList.add(systemTheme);
-			return;
-		}
-		root.classList.add(theme);
-	}, [theme]);
-	const value = {
-		theme,
-		setTheme: (theme$1) => {
-			setTheme(theme$1);
-			if (typeof window === "undefined") return;
-			localStorage.setItem(storageKey, theme$1);
-		}
-	};
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(ThemeProviderContext.Provider, {
-		...props,
-		value,
-		children
-	});
-}
-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__WEBPACK_IMPORTED_MODULE_0__.useCallback(composeRefs(...refs), refs);
-}
-/* @__NO_SIDE_EFFECTS__ */
-function createSlot(ownerName) {
-	const SlotClone = /* @__PURE__ */ createSlotClone(ownerName);
-	const Slot2 = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-		const { children, ...slotProps } = props;
-		const childrenArray = react__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.Children.count(newElement) > 1) return react__WEBPACK_IMPORTED_MODULE_0__.Children.only(null);
-					return react__WEBPACK_IMPORTED_MODULE_0__.isValidElement(newElement) ? newElement.props.children : null;
-				} else return child;
-			});
-			return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(SlotClone, {
-				...slotProps,
-				ref: forwardedRef,
-				children: react__WEBPACK_IMPORTED_MODULE_0__.isValidElement(newElement) ? react__WEBPACK_IMPORTED_MODULE_0__.cloneElement(newElement, void 0, newChildren) : null
-			});
-		}
-		return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(SlotClone, {
-			...slotProps,
-			ref: forwardedRef,
-			children
-		});
-	});
-	Slot2.displayName = `${ownerName}.Slot`;
-	return Slot2;
-}
-var Slot$1 = /* @__PURE__ */ createSlot("Slot");
-/* @__NO_SIDE_EFFECTS__ */
-function createSlotClone(ownerName) {
-	const SlotClone = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-		const { children, ...slotProps } = props;
-		if (react__WEBPACK_IMPORTED_MODULE_0__.isValidElement(children)) {
-			const childrenRef = getElementRef$1(children);
-			const props2 = mergeProps(slotProps, children.props);
-			if (children.type !== react__WEBPACK_IMPORTED_MODULE_0__.Fragment) props2.ref = forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef;
-			return react__WEBPACK_IMPORTED_MODULE_0__.cloneElement(children, props2);
-		}
-		return react__WEBPACK_IMPORTED_MODULE_0__.Children.count(children) > 1 ? react__WEBPACK_IMPORTED_MODULE_0__.Children.only(null) : null;
-	});
-	SlotClone.displayName = `${ownerName}.SlotClone`;
-	return SlotClone;
-}
-var SLOTTABLE_IDENTIFIER = Symbol("radix.slottable");
-function isSlottable(child) {
-	return react__WEBPACK_IMPORTED_MODULE_0__.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;
-}
-function r(e) {
-	var t, f, n = "";
-	if ("string" == typeof e || "number" == typeof e) n += e;
-	else if ("object" == typeof e) if (Array.isArray(e)) {
-		var o = e.length;
-		for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
-	} else for (f in e) e[f] && (n && (n += " "), n += f);
-	return n;
-}
-function clsx() {
-	for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
-	return n;
-}
-var falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
-const cx = clsx;
-const cva = (base, config) => (props) => {
-	var _config_compoundVariants;
-	if ((config === null || config === void 0 ? void 0 : config.variants) == null) return cx(base, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
-	const { variants, defaultVariants } = config;
-	const getVariantClassNames = Object.keys(variants).map((variant) => {
-		const variantProp = props === null || props === void 0 ? void 0 : props[variant];
-		const defaultVariantProp = defaultVariants === null || defaultVariants === void 0 ? void 0 : defaultVariants[variant];
-		if (variantProp === null) return null;
-		const variantKey = falsyToString(variantProp) || falsyToString(defaultVariantProp);
-		return variants[variant][variantKey];
-	});
-	const propsWithoutUndefined = props && Object.entries(props).reduce((acc, param) => {
-		let [key, value] = param;
-		if (value === void 0) return acc;
-		acc[key] = value;
-		return acc;
-	}, {});
-	return cx(base, getVariantClassNames, config === null || config === void 0 ? void 0 : (_config_compoundVariants = config.compoundVariants) === null || _config_compoundVariants === void 0 ? void 0 : _config_compoundVariants.reduce((acc, param) => {
-		let { class: cvClass, className: cvClassName, ...compoundVariantOptions } = param;
-		return Object.entries(compoundVariantOptions).every((param$1) => {
-			let [key, value] = param$1;
-			return Array.isArray(value) ? value.includes({
-				...defaultVariants,
-				...propsWithoutUndefined
-			}[key]) : {
-				...defaultVariants,
-				...propsWithoutUndefined
-			}[key] === value;
-		}) ? [
-			...acc,
-			cvClass,
-			cvClassName
-		] : acc;
-	}, []), props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
-};
-var CLASS_PART_SEPARATOR = "-";
-var createClassGroupUtils = (config) => {
-	const classMap = createClassMap(config);
-	const { conflictingClassGroups, conflictingClassGroupModifiers } = config;
-	const getClassGroupId = (className) => {
-		const classParts = className.split(CLASS_PART_SEPARATOR);
-		if (classParts[0] === "" && classParts.length !== 1) classParts.shift();
-		return getGroupRecursive(classParts, classMap) || getGroupIdForArbitraryProperty(className);
-	};
-	const getConflictingClassGroupIds = (classGroupId, hasPostfixModifier) => {
-		const conflicts = conflictingClassGroups[classGroupId] || [];
-		if (hasPostfixModifier && conflictingClassGroupModifiers[classGroupId]) return [...conflicts, ...conflictingClassGroupModifiers[classGroupId]];
-		return conflicts;
-	};
-	return {
-		getClassGroupId,
-		getConflictingClassGroupIds
-	};
-};
-var getGroupRecursive = (classParts, classPartObject) => {
-	if (classParts.length === 0) return classPartObject.classGroupId;
-	const currentClassPart = classParts[0];
-	const nextClassPartObject = classPartObject.nextPart.get(currentClassPart);
-	const classGroupFromNextClassPart = nextClassPartObject ? getGroupRecursive(classParts.slice(1), nextClassPartObject) : void 0;
-	if (classGroupFromNextClassPart) return classGroupFromNextClassPart;
-	if (classPartObject.validators.length === 0) return;
-	const classRest = classParts.join(CLASS_PART_SEPARATOR);
-	return classPartObject.validators.find(({ validator }) => validator(classRest))?.classGroupId;
-};
-var arbitraryPropertyRegex = /^\[(.+)\]$/;
-var getGroupIdForArbitraryProperty = (className) => {
-	if (arbitraryPropertyRegex.test(className)) {
-		const arbitraryPropertyClassName = arbitraryPropertyRegex.exec(className)[1];
-		const property = arbitraryPropertyClassName?.substring(0, arbitraryPropertyClassName.indexOf(":"));
-		if (property) return "arbitrary.." + property;
-	}
-};
-var createClassMap = (config) => {
-	const { theme, classGroups } = config;
-	const classMap = {
-		nextPart: /* @__PURE__ */ new Map(),
-		validators: []
-	};
-	for (const classGroupId in classGroups) processClassesRecursively(classGroups[classGroupId], classMap, classGroupId, theme);
-	return classMap;
-};
-var processClassesRecursively = (classGroup, classPartObject, classGroupId, theme) => {
-	classGroup.forEach((classDefinition) => {
-		if (typeof classDefinition === "string") {
-			const classPartObjectToEdit = classDefinition === "" ? classPartObject : getPart(classPartObject, classDefinition);
-			classPartObjectToEdit.classGroupId = classGroupId;
-			return;
-		}
-		if (typeof classDefinition === "function") {
-			if (isThemeGetter(classDefinition)) {
-				processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
-				return;
-			}
-			classPartObject.validators.push({
-				validator: classDefinition,
-				classGroupId
-			});
-			return;
-		}
-		Object.entries(classDefinition).forEach(([key, classGroup$1]) => {
-			processClassesRecursively(classGroup$1, getPart(classPartObject, key), classGroupId, theme);
-		});
-	});
-};
-var getPart = (classPartObject, path) => {
-	let currentClassPartObject = classPartObject;
-	path.split(CLASS_PART_SEPARATOR).forEach((pathPart) => {
-		if (!currentClassPartObject.nextPart.has(pathPart)) currentClassPartObject.nextPart.set(pathPart, {
-			nextPart: /* @__PURE__ */ new Map(),
-			validators: []
-		});
-		currentClassPartObject = currentClassPartObject.nextPart.get(pathPart);
-	});
-	return currentClassPartObject;
-};
-var isThemeGetter = (func) => func.isThemeGetter;
-var createLruCache = (maxCacheSize) => {
-	if (maxCacheSize < 1) return {
-		get: () => void 0,
-		set: () => {}
-	};
-	let cacheSize = 0;
-	let cache = /* @__PURE__ */ new Map();
-	let previousCache = /* @__PURE__ */ new Map();
-	const update = (key, value) => {
-		cache.set(key, value);
-		cacheSize++;
-		if (cacheSize > maxCacheSize) {
-			cacheSize = 0;
-			previousCache = cache;
-			cache = /* @__PURE__ */ new Map();
-		}
-	};
-	return {
-		get(key) {
-			let value = cache.get(key);
-			if (value !== void 0) return value;
-			if ((value = previousCache.get(key)) !== void 0) {
-				update(key, value);
-				return value;
-			}
-		},
-		set(key, value) {
-			if (cache.has(key)) cache.set(key, value);
-			else update(key, value);
-		}
-	};
-};
-var IMPORTANT_MODIFIER = "!";
-var MODIFIER_SEPARATOR = ":";
-var MODIFIER_SEPARATOR_LENGTH = 1;
-var createParseClassName = (config) => {
-	const { prefix, experimentalParseClassName } = config;
-	let parseClassName = (className) => {
-		const modifiers = [];
-		let bracketDepth = 0;
-		let parenDepth = 0;
-		let modifierStart = 0;
-		let postfixModifierPosition;
-		for (let index = 0; index < className.length; index++) {
-			let currentCharacter = className[index];
-			if (bracketDepth === 0 && parenDepth === 0) {
-				if (currentCharacter === MODIFIER_SEPARATOR) {
-					modifiers.push(className.slice(modifierStart, index));
-					modifierStart = index + MODIFIER_SEPARATOR_LENGTH;
-					continue;
-				}
-				if (currentCharacter === "/") {
-					postfixModifierPosition = index;
-					continue;
-				}
-			}
-			if (currentCharacter === "[") bracketDepth++;
-			else if (currentCharacter === "]") bracketDepth--;
-			else if (currentCharacter === "(") parenDepth++;
-			else if (currentCharacter === ")") parenDepth--;
-		}
-		const baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.substring(modifierStart);
-		const baseClassName = stripImportantModifier(baseClassNameWithImportantModifier);
-		return {
-			modifiers,
-			hasImportantModifier: baseClassName !== baseClassNameWithImportantModifier,
-			baseClassName,
-			maybePostfixModifierPosition: postfixModifierPosition && postfixModifierPosition > modifierStart ? postfixModifierPosition - modifierStart : void 0
-		};
-	};
-	if (prefix) {
-		const fullPrefix = prefix + MODIFIER_SEPARATOR;
-		const parseClassNameOriginal = parseClassName;
-		parseClassName = (className) => className.startsWith(fullPrefix) ? parseClassNameOriginal(className.substring(fullPrefix.length)) : {
-			isExternal: true,
-			modifiers: [],
-			hasImportantModifier: false,
-			baseClassName: className,
-			maybePostfixModifierPosition: void 0
-		};
-	}
-	if (experimentalParseClassName) {
-		const parseClassNameOriginal = parseClassName;
-		parseClassName = (className) => experimentalParseClassName({
-			className,
-			parseClassName: parseClassNameOriginal
-		});
-	}
-	return parseClassName;
-};
-var stripImportantModifier = (baseClassName) => {
-	if (baseClassName.endsWith(IMPORTANT_MODIFIER)) return baseClassName.substring(0, baseClassName.length - 1);
-	if (baseClassName.startsWith(IMPORTANT_MODIFIER)) return baseClassName.substring(1);
-	return baseClassName;
-};
-var createSortModifiers = (config) => {
-	const orderSensitiveModifiers = Object.fromEntries(config.orderSensitiveModifiers.map((modifier) => [modifier, true]));
-	const sortModifiers = (modifiers) => {
-		if (modifiers.length <= 1) return modifiers;
-		const sortedModifiers = [];
-		let unsortedModifiers = [];
-		modifiers.forEach((modifier) => {
-			if (modifier[0] === "[" || orderSensitiveModifiers[modifier]) {
-				sortedModifiers.push(...unsortedModifiers.sort(), modifier);
-				unsortedModifiers = [];
-			} else unsortedModifiers.push(modifier);
-		});
-		sortedModifiers.push(...unsortedModifiers.sort());
-		return sortedModifiers;
-	};
-	return sortModifiers;
-};
-var createConfigUtils = (config) => ({
-	cache: createLruCache(config.cacheSize),
-	parseClassName: createParseClassName(config),
-	sortModifiers: createSortModifiers(config),
-	...createClassGroupUtils(config)
-});
-var SPLIT_CLASSES_REGEX = /\s+/;
-var mergeClassList = (classList, configUtils) => {
-	const { parseClassName, getClassGroupId, getConflictingClassGroupIds, sortModifiers } = configUtils;
-	const classGroupsInConflict = [];
-	const classNames = classList.trim().split(SPLIT_CLASSES_REGEX);
-	let result = "";
-	for (let index = classNames.length - 1; index >= 0; index -= 1) {
-		const originalClassName = classNames[index];
-		const { isExternal, modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition } = parseClassName(originalClassName);
-		if (isExternal) {
-			result = originalClassName + (result.length > 0 ? " " + result : result);
-			continue;
-		}
-		let hasPostfixModifier = !!maybePostfixModifierPosition;
-		let classGroupId = getClassGroupId(hasPostfixModifier ? baseClassName.substring(0, maybePostfixModifierPosition) : baseClassName);
-		if (!classGroupId) {
-			if (!hasPostfixModifier) {
-				result = originalClassName + (result.length > 0 ? " " + result : result);
-				continue;
-			}
-			classGroupId = getClassGroupId(baseClassName);
-			if (!classGroupId) {
-				result = originalClassName + (result.length > 0 ? " " + result : result);
-				continue;
-			}
-			hasPostfixModifier = false;
-		}
-		const variantModifier = sortModifiers(modifiers).join(":");
-		const modifierId = hasImportantModifier ? variantModifier + IMPORTANT_MODIFIER : variantModifier;
-		const classId = modifierId + classGroupId;
-		if (classGroupsInConflict.includes(classId)) continue;
-		classGroupsInConflict.push(classId);
-		const conflictGroups = getConflictingClassGroupIds(classGroupId, hasPostfixModifier);
-		for (let i = 0; i < conflictGroups.length; ++i) {
-			const group = conflictGroups[i];
-			classGroupsInConflict.push(modifierId + group);
-		}
-		result = originalClassName + (result.length > 0 ? " " + result : result);
-	}
-	return result;
-};
-function twJoin() {
-	let index = 0;
-	let argument;
-	let resolvedValue;
-	let string = "";
-	while (index < arguments.length) if (argument = arguments[index++]) {
-		if (resolvedValue = toValue(argument)) {
-			string && (string += " ");
-			string += resolvedValue;
-		}
-	}
-	return string;
-}
-var toValue = (mix) => {
-	if (typeof mix === "string") return mix;
-	let resolvedValue;
-	let string = "";
-	for (let k = 0; k < mix.length; k++) if (mix[k]) {
-		if (resolvedValue = toValue(mix[k])) {
-			string && (string += " ");
-			string += resolvedValue;
-		}
-	}
-	return string;
-};
-function createTailwindMerge(createConfigFirst, ...createConfigRest) {
-	let configUtils;
-	let cacheGet;
-	let cacheSet;
-	let functionToCall = initTailwindMerge;
-	function initTailwindMerge(classList) {
-		configUtils = createConfigUtils(createConfigRest.reduce((previousConfig, createConfigCurrent) => createConfigCurrent(previousConfig), createConfigFirst()));
-		cacheGet = configUtils.cache.get;
-		cacheSet = configUtils.cache.set;
-		functionToCall = tailwindMerge;
-		return tailwindMerge(classList);
-	}
-	function tailwindMerge(classList) {
-		const cachedResult = cacheGet(classList);
-		if (cachedResult) return cachedResult;
-		const result = mergeClassList(classList, configUtils);
-		cacheSet(classList, result);
-		return result;
-	}
-	return function callTailwindMerge() {
-		return functionToCall(twJoin.apply(null, arguments));
-	};
-}
-var fromTheme = (key) => {
-	const themeGetter = (theme) => theme[key] || [];
-	themeGetter.isThemeGetter = true;
-	return themeGetter;
-};
-var arbitraryValueRegex = /^\[(?:(\w[\w-]*):)?(.+)\]$/i;
-var arbitraryVariableRegex = /^\((?:(\w[\w-]*):)?(.+)\)$/i;
-var fractionRegex = /^\d+\/\d+$/;
-var tshirtUnitRegex = /^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/;
-var lengthUnitRegex = /\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/;
-var colorFunctionRegex = /^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/;
-var shadowRegex = /^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/;
-var imageRegex = /^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/;
-var isFraction = (value) => fractionRegex.test(value);
-var isNumber = (value) => !!value && !Number.isNaN(Number(value));
-var isInteger = (value) => !!value && Number.isInteger(Number(value));
-var isPercent = (value) => value.endsWith("%") && isNumber(value.slice(0, -1));
-var isTshirtSize = (value) => tshirtUnitRegex.test(value);
-var isAny = () => true;
-var isLengthOnly = (value) => lengthUnitRegex.test(value) && !colorFunctionRegex.test(value);
-var isNever = () => false;
-var isShadow = (value) => shadowRegex.test(value);
-var isImage = (value) => imageRegex.test(value);
-var isAnyNonArbitrary = (value) => !isArbitraryValue(value) && !isArbitraryVariable(value);
-var isArbitrarySize = (value) => getIsArbitraryValue(value, isLabelSize, isNever);
-var isArbitraryValue = (value) => arbitraryValueRegex.test(value);
-var isArbitraryLength = (value) => getIsArbitraryValue(value, isLabelLength, isLengthOnly);
-var isArbitraryNumber = (value) => getIsArbitraryValue(value, isLabelNumber, isNumber);
-var isArbitraryPosition = (value) => getIsArbitraryValue(value, isLabelPosition, isNever);
-var isArbitraryImage = (value) => getIsArbitraryValue(value, isLabelImage, isImage);
-var isArbitraryShadow = (value) => getIsArbitraryValue(value, isLabelShadow, isShadow);
-var isArbitraryVariable = (value) => arbitraryVariableRegex.test(value);
-var isArbitraryVariableLength = (value) => getIsArbitraryVariable(value, isLabelLength);
-var isArbitraryVariableFamilyName = (value) => getIsArbitraryVariable(value, isLabelFamilyName);
-var isArbitraryVariablePosition = (value) => getIsArbitraryVariable(value, isLabelPosition);
-var isArbitraryVariableSize = (value) => getIsArbitraryVariable(value, isLabelSize);
-var isArbitraryVariableImage = (value) => getIsArbitraryVariable(value, isLabelImage);
-var isArbitraryVariableShadow = (value) => getIsArbitraryVariable(value, isLabelShadow, true);
-var getIsArbitraryValue = (value, testLabel, testValue) => {
-	const result = arbitraryValueRegex.exec(value);
-	if (result) {
-		if (result[1]) return testLabel(result[1]);
-		return testValue(result[2]);
-	}
-	return false;
-};
-var getIsArbitraryVariable = (value, testLabel, shouldMatchNoLabel = false) => {
-	const result = arbitraryVariableRegex.exec(value);
-	if (result) {
-		if (result[1]) return testLabel(result[1]);
-		return shouldMatchNoLabel;
-	}
-	return false;
-};
-var isLabelPosition = (label) => label === "position" || label === "percentage";
-var isLabelImage = (label) => label === "image" || label === "url";
-var isLabelSize = (label) => label === "length" || label === "size" || label === "bg-size";
-var isLabelLength = (label) => label === "length";
-var isLabelNumber = (label) => label === "number";
-var isLabelFamilyName = (label) => label === "family-name";
-var isLabelShadow = (label) => label === "shadow";
-var getDefaultConfig = () => {
-	const themeColor = fromTheme("color");
-	const themeFont = fromTheme("font");
-	const themeText = fromTheme("text");
-	const themeFontWeight = fromTheme("font-weight");
-	const themeTracking = fromTheme("tracking");
-	const themeLeading = fromTheme("leading");
-	const themeBreakpoint = fromTheme("breakpoint");
-	const themeContainer = fromTheme("container");
-	const themeSpacing = fromTheme("spacing");
-	const themeRadius = fromTheme("radius");
-	const themeShadow = fromTheme("shadow");
-	const themeInsetShadow = fromTheme("inset-shadow");
-	const themeTextShadow = fromTheme("text-shadow");
-	const themeDropShadow = fromTheme("drop-shadow");
-	const themeBlur = fromTheme("blur");
-	const themePerspective = fromTheme("perspective");
-	const themeAspect = fromTheme("aspect");
-	const themeEase = fromTheme("ease");
-	const themeAnimate = fromTheme("animate");
-	const scaleBreak = () => [
-		"auto",
-		"avoid",
-		"all",
-		"avoid-page",
-		"page",
-		"left",
-		"right",
-		"column"
-	];
-	const scalePosition = () => [
-		"center",
-		"top",
-		"bottom",
-		"left",
-		"right",
-		"top-left",
-		"left-top",
-		"top-right",
-		"right-top",
-		"bottom-right",
-		"right-bottom",
-		"bottom-left",
-		"left-bottom"
-	];
-	const scalePositionWithArbitrary = () => [
-		...scalePosition(),
-		isArbitraryVariable,
-		isArbitraryValue
-	];
-	const scaleOverflow = () => [
-		"auto",
-		"hidden",
-		"clip",
-		"visible",
-		"scroll"
-	];
-	const scaleOverscroll = () => [
-		"auto",
-		"contain",
-		"none"
-	];
-	const scaleUnambiguousSpacing = () => [
-		isArbitraryVariable,
-		isArbitraryValue,
-		themeSpacing
-	];
-	const scaleInset = () => [
-		isFraction,
-		"full",
-		"auto",
-		...scaleUnambiguousSpacing()
-	];
-	const scaleGridTemplateColsRows = () => [
-		isInteger,
-		"none",
-		"subgrid",
-		isArbitraryVariable,
-		isArbitraryValue
-	];
-	const scaleGridColRowStartAndEnd = () => [
-		"auto",
-		{ span: [
-			"full",
-			isInteger,
-			isArbitraryVariable,
-			isArbitraryValue
-		] },
-		isInteger,
-		isArbitraryVariable,
-		isArbitraryValue
-	];
-	const scaleGridColRowStartOrEnd = () => [
-		isInteger,
-		"auto",
-		isArbitraryVariable,
-		isArbitraryValue
-	];
-	const scaleGridAutoColsRows = () => [
-		"auto",
-		"min",
-		"max",
-		"fr",
-		isArbitraryVariable,
-		isArbitraryValue
-	];
-	const scaleAlignPrimaryAxis = () => [
-		"start",
-		"end",
-		"center",
-		"between",
-		"around",
-		"evenly",
-		"stretch",
-		"baseline",
-		"center-safe",
-		"end-safe"
-	];
-	const scaleAlignSecondaryAxis = () => [
-		"start",
-		"end",
-		"center",
-		"stretch",
-		"center-safe",
-		"end-safe"
-	];
-	const scaleMargin = () => ["auto", ...scaleUnambiguousSpacing()];
-	const scaleSizing = () => [
-		isFraction,
-		"auto",
-		"full",
-		"dvw",
-		"dvh",
-		"lvw",
-		"lvh",
-		"svw",
-		"svh",
-		"min",
-		"max",
-		"fit",
-		...scaleUnambiguousSpacing()
-	];
-	const scaleColor = () => [
-		themeColor,
-		isArbitraryVariable,
-		isArbitraryValue
-	];
-	const scaleBgPosition = () => [
-		...scalePosition(),
-		isArbitraryVariablePosition,
-		isArbitraryPosition,
-		{ position: [isArbitraryVariable, isArbitraryValue] }
-	];
-	const scaleBgRepeat = () => ["no-repeat", { repeat: [
-		"",
-		"x",
-		"y",
-		"space",
-		"round"
-	] }];
-	const scaleBgSize = () => [
-		"auto",
-		"cover",
-		"contain",
-		isArbitraryVariableSize,
-		isArbitrarySize,
-		{ size: [isArbitraryVariable, isArbitraryValue] }
-	];
-	const scaleGradientStopPosition = () => [
-		isPercent,
-		isArbitraryVariableLength,
-		isArbitraryLength
-	];
-	const scaleRadius = () => [
-		"",
-		"none",
-		"full",
-		themeRadius,
-		isArbitraryVariable,
-		isArbitraryValue
-	];
-	const scaleBorderWidth = () => [
-		"",
-		isNumber,
-		isArbitraryVariableLength,
-		isArbitraryLength
-	];
-	const scaleLineStyle = () => [
-		"solid",
-		"dashed",
-		"dotted",
-		"double"
-	];
-	const scaleBlendMode = () => [
-		"normal",
-		"multiply",
-		"screen",
-		"overlay",
-		"darken",
-		"lighten",
-		"color-dodge",
-		"color-burn",
-		"hard-light",
-		"soft-light",
-		"difference",
-		"exclusion",
-		"hue",
-		"saturation",
-		"color",
-		"luminosity"
-	];
-	const scaleMaskImagePosition = () => [
-		isNumber,
-		isPercent,
-		isArbitraryVariablePosition,
-		isArbitraryPosition
-	];
-	const scaleBlur = () => [
-		"",
-		"none",
-		themeBlur,
-		isArbitraryVariable,
-		isArbitraryValue
-	];
-	const scaleRotate = () => [
-		"none",
-		isNumber,
-		isArbitraryVariable,
-		isArbitraryValue
-	];
-	const scaleScale = () => [
-		"none",
-		isNumber,
-		isArbitraryVariable,
-		isArbitraryValue
-	];
-	const scaleSkew = () => [
-		isNumber,
-		isArbitraryVariable,
-		isArbitraryValue
-	];
-	const scaleTranslate = () => [
-		isFraction,
-		"full",
-		...scaleUnambiguousSpacing()
-	];
-	return {
-		cacheSize: 500,
-		theme: {
-			animate: [
-				"spin",
-				"ping",
-				"pulse",
-				"bounce"
-			],
-			aspect: ["video"],
-			blur: [isTshirtSize],
-			breakpoint: [isTshirtSize],
-			color: [isAny],
-			container: [isTshirtSize],
-			"drop-shadow": [isTshirtSize],
-			ease: [
-				"in",
-				"out",
-				"in-out"
-			],
-			font: [isAnyNonArbitrary],
-			"font-weight": [
-				"thin",
-				"extralight",
-				"light",
-				"normal",
-				"medium",
-				"semibold",
-				"bold",
-				"extrabold",
-				"black"
-			],
-			"inset-shadow": [isTshirtSize],
-			leading: [
-				"none",
-				"tight",
-				"snug",
-				"normal",
-				"relaxed",
-				"loose"
-			],
-			perspective: [
-				"dramatic",
-				"near",
-				"normal",
-				"midrange",
-				"distant",
-				"none"
-			],
-			radius: [isTshirtSize],
-			shadow: [isTshirtSize],
-			spacing: ["px", isNumber],
-			text: [isTshirtSize],
-			"text-shadow": [isTshirtSize],
-			tracking: [
-				"tighter",
-				"tight",
-				"normal",
-				"wide",
-				"wider",
-				"widest"
-			]
-		},
-		classGroups: {
-			aspect: [{ aspect: [
-				"auto",
-				"square",
-				isFraction,
-				isArbitraryValue,
-				isArbitraryVariable,
-				themeAspect
-			] }],
-			container: ["container"],
-			columns: [{ columns: [
-				isNumber,
-				isArbitraryValue,
-				isArbitraryVariable,
-				themeContainer
-			] }],
-			"break-after": [{ "break-after": scaleBreak() }],
-			"break-before": [{ "break-before": scaleBreak() }],
-			"break-inside": [{ "break-inside": [
-				"auto",
-				"avoid",
-				"avoid-page",
-				"avoid-column"
-			] }],
-			"box-decoration": [{ "box-decoration": ["slice", "clone"] }],
-			box: [{ box: ["border", "content"] }],
-			display: [
-				"block",
-				"inline-block",
-				"inline",
-				"flex",
-				"inline-flex",
-				"table",
-				"inline-table",
-				"table-caption",
-				"table-cell",
-				"table-column",
-				"table-column-group",
-				"table-footer-group",
-				"table-header-group",
-				"table-row-group",
-				"table-row",
-				"flow-root",
-				"grid",
-				"inline-grid",
-				"contents",
-				"list-item",
-				"hidden"
-			],
-			sr: ["sr-only", "not-sr-only"],
-			float: [{ float: [
-				"right",
-				"left",
-				"none",
-				"start",
-				"end"
-			] }],
-			clear: [{ clear: [
-				"left",
-				"right",
-				"both",
-				"none",
-				"start",
-				"end"
-			] }],
-			isolation: ["isolate", "isolation-auto"],
-			"object-fit": [{ object: [
-				"contain",
-				"cover",
-				"fill",
-				"none",
-				"scale-down"
-			] }],
-			"object-position": [{ object: scalePositionWithArbitrary() }],
-			overflow: [{ overflow: scaleOverflow() }],
-			"overflow-x": [{ "overflow-x": scaleOverflow() }],
-			"overflow-y": [{ "overflow-y": scaleOverflow() }],
-			overscroll: [{ overscroll: scaleOverscroll() }],
-			"overscroll-x": [{ "overscroll-x": scaleOverscroll() }],
-			"overscroll-y": [{ "overscroll-y": scaleOverscroll() }],
-			position: [
-				"static",
-				"fixed",
-				"absolute",
-				"relative",
-				"sticky"
-			],
-			inset: [{ inset: scaleInset() }],
-			"inset-x": [{ "inset-x": scaleInset() }],
-			"inset-y": [{ "inset-y": scaleInset() }],
-			start: [{ start: scaleInset() }],
-			end: [{ end: scaleInset() }],
-			top: [{ top: scaleInset() }],
-			right: [{ right: scaleInset() }],
-			bottom: [{ bottom: scaleInset() }],
-			left: [{ left: scaleInset() }],
-			visibility: [
-				"visible",
-				"invisible",
-				"collapse"
-			],
-			z: [{ z: [
-				isInteger,
-				"auto",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			basis: [{ basis: [
-				isFraction,
-				"full",
-				"auto",
-				themeContainer,
-				...scaleUnambiguousSpacing()
-			] }],
-			"flex-direction": [{ flex: [
-				"row",
-				"row-reverse",
-				"col",
-				"col-reverse"
-			] }],
-			"flex-wrap": [{ flex: [
-				"nowrap",
-				"wrap",
-				"wrap-reverse"
-			] }],
-			flex: [{ flex: [
-				isNumber,
-				isFraction,
-				"auto",
-				"initial",
-				"none",
-				isArbitraryValue
-			] }],
-			grow: [{ grow: [
-				"",
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			shrink: [{ shrink: [
-				"",
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			order: [{ order: [
-				isInteger,
-				"first",
-				"last",
-				"none",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"grid-cols": [{ "grid-cols": scaleGridTemplateColsRows() }],
-			"col-start-end": [{ col: scaleGridColRowStartAndEnd() }],
-			"col-start": [{ "col-start": scaleGridColRowStartOrEnd() }],
-			"col-end": [{ "col-end": scaleGridColRowStartOrEnd() }],
-			"grid-rows": [{ "grid-rows": scaleGridTemplateColsRows() }],
-			"row-start-end": [{ row: scaleGridColRowStartAndEnd() }],
-			"row-start": [{ "row-start": scaleGridColRowStartOrEnd() }],
-			"row-end": [{ "row-end": scaleGridColRowStartOrEnd() }],
-			"grid-flow": [{ "grid-flow": [
-				"row",
-				"col",
-				"dense",
-				"row-dense",
-				"col-dense"
-			] }],
-			"auto-cols": [{ "auto-cols": scaleGridAutoColsRows() }],
-			"auto-rows": [{ "auto-rows": scaleGridAutoColsRows() }],
-			gap: [{ gap: scaleUnambiguousSpacing() }],
-			"gap-x": [{ "gap-x": scaleUnambiguousSpacing() }],
-			"gap-y": [{ "gap-y": scaleUnambiguousSpacing() }],
-			"justify-content": [{ justify: [...scaleAlignPrimaryAxis(), "normal"] }],
-			"justify-items": [{ "justify-items": [...scaleAlignSecondaryAxis(), "normal"] }],
-			"justify-self": [{ "justify-self": ["auto", ...scaleAlignSecondaryAxis()] }],
-			"align-content": [{ content: ["normal", ...scaleAlignPrimaryAxis()] }],
-			"align-items": [{ items: [...scaleAlignSecondaryAxis(), { baseline: ["", "last"] }] }],
-			"align-self": [{ self: [
-				"auto",
-				...scaleAlignSecondaryAxis(),
-				{ baseline: ["", "last"] }
-			] }],
-			"place-content": [{ "place-content": scaleAlignPrimaryAxis() }],
-			"place-items": [{ "place-items": [...scaleAlignSecondaryAxis(), "baseline"] }],
-			"place-self": [{ "place-self": ["auto", ...scaleAlignSecondaryAxis()] }],
-			p: [{ p: scaleUnambiguousSpacing() }],
-			px: [{ px: scaleUnambiguousSpacing() }],
-			py: [{ py: scaleUnambiguousSpacing() }],
-			ps: [{ ps: scaleUnambiguousSpacing() }],
-			pe: [{ pe: scaleUnambiguousSpacing() }],
-			pt: [{ pt: scaleUnambiguousSpacing() }],
-			pr: [{ pr: scaleUnambiguousSpacing() }],
-			pb: [{ pb: scaleUnambiguousSpacing() }],
-			pl: [{ pl: scaleUnambiguousSpacing() }],
-			m: [{ m: scaleMargin() }],
-			mx: [{ mx: scaleMargin() }],
-			my: [{ my: scaleMargin() }],
-			ms: [{ ms: scaleMargin() }],
-			me: [{ me: scaleMargin() }],
-			mt: [{ mt: scaleMargin() }],
-			mr: [{ mr: scaleMargin() }],
-			mb: [{ mb: scaleMargin() }],
-			ml: [{ ml: scaleMargin() }],
-			"space-x": [{ "space-x": scaleUnambiguousSpacing() }],
-			"space-x-reverse": ["space-x-reverse"],
-			"space-y": [{ "space-y": scaleUnambiguousSpacing() }],
-			"space-y-reverse": ["space-y-reverse"],
-			size: [{ size: scaleSizing() }],
-			w: [{ w: [
-				themeContainer,
-				"screen",
-				...scaleSizing()
-			] }],
-			"min-w": [{ "min-w": [
-				themeContainer,
-				"screen",
-				"none",
-				...scaleSizing()
-			] }],
-			"max-w": [{ "max-w": [
-				themeContainer,
-				"screen",
-				"none",
-				"prose",
-				{ screen: [themeBreakpoint] },
-				...scaleSizing()
-			] }],
-			h: [{ h: [
-				"screen",
-				"lh",
-				...scaleSizing()
-			] }],
-			"min-h": [{ "min-h": [
-				"screen",
-				"lh",
-				"none",
-				...scaleSizing()
-			] }],
-			"max-h": [{ "max-h": [
-				"screen",
-				"lh",
-				...scaleSizing()
-			] }],
-			"font-size": [{ text: [
-				"base",
-				themeText,
-				isArbitraryVariableLength,
-				isArbitraryLength
-			] }],
-			"font-smoothing": ["antialiased", "subpixel-antialiased"],
-			"font-style": ["italic", "not-italic"],
-			"font-weight": [{ font: [
-				themeFontWeight,
-				isArbitraryVariable,
-				isArbitraryNumber
-			] }],
-			"font-stretch": [{ "font-stretch": [
-				"ultra-condensed",
-				"extra-condensed",
-				"condensed",
-				"semi-condensed",
-				"normal",
-				"semi-expanded",
-				"expanded",
-				"extra-expanded",
-				"ultra-expanded",
-				isPercent,
-				isArbitraryValue
-			] }],
-			"font-family": [{ font: [
-				isArbitraryVariableFamilyName,
-				isArbitraryValue,
-				themeFont
-			] }],
-			"fvn-normal": ["normal-nums"],
-			"fvn-ordinal": ["ordinal"],
-			"fvn-slashed-zero": ["slashed-zero"],
-			"fvn-figure": ["lining-nums", "oldstyle-nums"],
-			"fvn-spacing": ["proportional-nums", "tabular-nums"],
-			"fvn-fraction": ["diagonal-fractions", "stacked-fractions"],
-			tracking: [{ tracking: [
-				themeTracking,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"line-clamp": [{ "line-clamp": [
-				isNumber,
-				"none",
-				isArbitraryVariable,
-				isArbitraryNumber
-			] }],
-			leading: [{ leading: [themeLeading, ...scaleUnambiguousSpacing()] }],
-			"list-image": [{ "list-image": [
-				"none",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"list-style-position": [{ list: ["inside", "outside"] }],
-			"list-style-type": [{ list: [
-				"disc",
-				"decimal",
-				"none",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"text-alignment": [{ text: [
-				"left",
-				"center",
-				"right",
-				"justify",
-				"start",
-				"end"
-			] }],
-			"placeholder-color": [{ placeholder: scaleColor() }],
-			"text-color": [{ text: scaleColor() }],
-			"text-decoration": [
-				"underline",
-				"overline",
-				"line-through",
-				"no-underline"
-			],
-			"text-decoration-style": [{ decoration: [...scaleLineStyle(), "wavy"] }],
-			"text-decoration-thickness": [{ decoration: [
-				isNumber,
-				"from-font",
-				"auto",
-				isArbitraryVariable,
-				isArbitraryLength
-			] }],
-			"text-decoration-color": [{ decoration: scaleColor() }],
-			"underline-offset": [{ "underline-offset": [
-				isNumber,
-				"auto",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"text-transform": [
-				"uppercase",
-				"lowercase",
-				"capitalize",
-				"normal-case"
-			],
-			"text-overflow": [
-				"truncate",
-				"text-ellipsis",
-				"text-clip"
-			],
-			"text-wrap": [{ text: [
-				"wrap",
-				"nowrap",
-				"balance",
-				"pretty"
-			] }],
-			indent: [{ indent: scaleUnambiguousSpacing() }],
-			"vertical-align": [{ align: [
-				"baseline",
-				"top",
-				"middle",
-				"bottom",
-				"text-top",
-				"text-bottom",
-				"sub",
-				"super",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			whitespace: [{ whitespace: [
-				"normal",
-				"nowrap",
-				"pre",
-				"pre-line",
-				"pre-wrap",
-				"break-spaces"
-			] }],
-			break: [{ break: [
-				"normal",
-				"words",
-				"all",
-				"keep"
-			] }],
-			wrap: [{ wrap: [
-				"break-word",
-				"anywhere",
-				"normal"
-			] }],
-			hyphens: [{ hyphens: [
-				"none",
-				"manual",
-				"auto"
-			] }],
-			content: [{ content: [
-				"none",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"bg-attachment": [{ bg: [
-				"fixed",
-				"local",
-				"scroll"
-			] }],
-			"bg-clip": [{ "bg-clip": [
-				"border",
-				"padding",
-				"content",
-				"text"
-			] }],
-			"bg-origin": [{ "bg-origin": [
-				"border",
-				"padding",
-				"content"
-			] }],
-			"bg-position": [{ bg: scaleBgPosition() }],
-			"bg-repeat": [{ bg: scaleBgRepeat() }],
-			"bg-size": [{ bg: scaleBgSize() }],
-			"bg-image": [{ bg: [
-				"none",
-				{
-					linear: [
-						{ to: [
-							"t",
-							"tr",
-							"r",
-							"br",
-							"b",
-							"bl",
-							"l",
-							"tl"
-						] },
-						isInteger,
-						isArbitraryVariable,
-						isArbitraryValue
-					],
-					radial: [
-						"",
-						isArbitraryVariable,
-						isArbitraryValue
-					],
-					conic: [
-						isInteger,
-						isArbitraryVariable,
-						isArbitraryValue
-					]
-				},
-				isArbitraryVariableImage,
-				isArbitraryImage
-			] }],
-			"bg-color": [{ bg: scaleColor() }],
-			"gradient-from-pos": [{ from: scaleGradientStopPosition() }],
-			"gradient-via-pos": [{ via: scaleGradientStopPosition() }],
-			"gradient-to-pos": [{ to: scaleGradientStopPosition() }],
-			"gradient-from": [{ from: scaleColor() }],
-			"gradient-via": [{ via: scaleColor() }],
-			"gradient-to": [{ to: scaleColor() }],
-			rounded: [{ rounded: scaleRadius() }],
-			"rounded-s": [{ "rounded-s": scaleRadius() }],
-			"rounded-e": [{ "rounded-e": scaleRadius() }],
-			"rounded-t": [{ "rounded-t": scaleRadius() }],
-			"rounded-r": [{ "rounded-r": scaleRadius() }],
-			"rounded-b": [{ "rounded-b": scaleRadius() }],
-			"rounded-l": [{ "rounded-l": scaleRadius() }],
-			"rounded-ss": [{ "rounded-ss": scaleRadius() }],
-			"rounded-se": [{ "rounded-se": scaleRadius() }],
-			"rounded-ee": [{ "rounded-ee": scaleRadius() }],
-			"rounded-es": [{ "rounded-es": scaleRadius() }],
-			"rounded-tl": [{ "rounded-tl": scaleRadius() }],
-			"rounded-tr": [{ "rounded-tr": scaleRadius() }],
-			"rounded-br": [{ "rounded-br": scaleRadius() }],
-			"rounded-bl": [{ "rounded-bl": scaleRadius() }],
-			"border-w": [{ border: scaleBorderWidth() }],
-			"border-w-x": [{ "border-x": scaleBorderWidth() }],
-			"border-w-y": [{ "border-y": scaleBorderWidth() }],
-			"border-w-s": [{ "border-s": scaleBorderWidth() }],
-			"border-w-e": [{ "border-e": scaleBorderWidth() }],
-			"border-w-t": [{ "border-t": scaleBorderWidth() }],
-			"border-w-r": [{ "border-r": scaleBorderWidth() }],
-			"border-w-b": [{ "border-b": scaleBorderWidth() }],
-			"border-w-l": [{ "border-l": scaleBorderWidth() }],
-			"divide-x": [{ "divide-x": scaleBorderWidth() }],
-			"divide-x-reverse": ["divide-x-reverse"],
-			"divide-y": [{ "divide-y": scaleBorderWidth() }],
-			"divide-y-reverse": ["divide-y-reverse"],
-			"border-style": [{ border: [
-				...scaleLineStyle(),
-				"hidden",
-				"none"
-			] }],
-			"divide-style": [{ divide: [
-				...scaleLineStyle(),
-				"hidden",
-				"none"
-			] }],
-			"border-color": [{ border: scaleColor() }],
-			"border-color-x": [{ "border-x": scaleColor() }],
-			"border-color-y": [{ "border-y": scaleColor() }],
-			"border-color-s": [{ "border-s": scaleColor() }],
-			"border-color-e": [{ "border-e": scaleColor() }],
-			"border-color-t": [{ "border-t": scaleColor() }],
-			"border-color-r": [{ "border-r": scaleColor() }],
-			"border-color-b": [{ "border-b": scaleColor() }],
-			"border-color-l": [{ "border-l": scaleColor() }],
-			"divide-color": [{ divide: scaleColor() }],
-			"outline-style": [{ outline: [
-				...scaleLineStyle(),
-				"none",
-				"hidden"
-			] }],
-			"outline-offset": [{ "outline-offset": [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"outline-w": [{ outline: [
-				"",
-				isNumber,
-				isArbitraryVariableLength,
-				isArbitraryLength
-			] }],
-			"outline-color": [{ outline: scaleColor() }],
-			shadow: [{ shadow: [
-				"",
-				"none",
-				themeShadow,
-				isArbitraryVariableShadow,
-				isArbitraryShadow
-			] }],
-			"shadow-color": [{ shadow: scaleColor() }],
-			"inset-shadow": [{ "inset-shadow": [
-				"none",
-				themeInsetShadow,
-				isArbitraryVariableShadow,
-				isArbitraryShadow
-			] }],
-			"inset-shadow-color": [{ "inset-shadow": scaleColor() }],
-			"ring-w": [{ ring: scaleBorderWidth() }],
-			"ring-w-inset": ["ring-inset"],
-			"ring-color": [{ ring: scaleColor() }],
-			"ring-offset-w": [{ "ring-offset": [isNumber, isArbitraryLength] }],
-			"ring-offset-color": [{ "ring-offset": scaleColor() }],
-			"inset-ring-w": [{ "inset-ring": scaleBorderWidth() }],
-			"inset-ring-color": [{ "inset-ring": scaleColor() }],
-			"text-shadow": [{ "text-shadow": [
-				"none",
-				themeTextShadow,
-				isArbitraryVariableShadow,
-				isArbitraryShadow
-			] }],
-			"text-shadow-color": [{ "text-shadow": scaleColor() }],
-			opacity: [{ opacity: [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"mix-blend": [{ "mix-blend": [
-				...scaleBlendMode(),
-				"plus-darker",
-				"plus-lighter"
-			] }],
-			"bg-blend": [{ "bg-blend": scaleBlendMode() }],
-			"mask-clip": [{ "mask-clip": [
-				"border",
-				"padding",
-				"content",
-				"fill",
-				"stroke",
-				"view"
-			] }, "mask-no-clip"],
-			"mask-composite": [{ mask: [
-				"add",
-				"subtract",
-				"intersect",
-				"exclude"
-			] }],
-			"mask-image-linear-pos": [{ "mask-linear": [isNumber] }],
-			"mask-image-linear-from-pos": [{ "mask-linear-from": scaleMaskImagePosition() }],
-			"mask-image-linear-to-pos": [{ "mask-linear-to": scaleMaskImagePosition() }],
-			"mask-image-linear-from-color": [{ "mask-linear-from": scaleColor() }],
-			"mask-image-linear-to-color": [{ "mask-linear-to": scaleColor() }],
-			"mask-image-t-from-pos": [{ "mask-t-from": scaleMaskImagePosition() }],
-			"mask-image-t-to-pos": [{ "mask-t-to": scaleMaskImagePosition() }],
-			"mask-image-t-from-color": [{ "mask-t-from": scaleColor() }],
-			"mask-image-t-to-color": [{ "mask-t-to": scaleColor() }],
-			"mask-image-r-from-pos": [{ "mask-r-from": scaleMaskImagePosition() }],
-			"mask-image-r-to-pos": [{ "mask-r-to": scaleMaskImagePosition() }],
-			"mask-image-r-from-color": [{ "mask-r-from": scaleColor() }],
-			"mask-image-r-to-color": [{ "mask-r-to": scaleColor() }],
-			"mask-image-b-from-pos": [{ "mask-b-from": scaleMaskImagePosition() }],
-			"mask-image-b-to-pos": [{ "mask-b-to": scaleMaskImagePosition() }],
-			"mask-image-b-from-color": [{ "mask-b-from": scaleColor() }],
-			"mask-image-b-to-color": [{ "mask-b-to": scaleColor() }],
-			"mask-image-l-from-pos": [{ "mask-l-from": scaleMaskImagePosition() }],
-			"mask-image-l-to-pos": [{ "mask-l-to": scaleMaskImagePosition() }],
-			"mask-image-l-from-color": [{ "mask-l-from": scaleColor() }],
-			"mask-image-l-to-color": [{ "mask-l-to": scaleColor() }],
-			"mask-image-x-from-pos": [{ "mask-x-from": scaleMaskImagePosition() }],
-			"mask-image-x-to-pos": [{ "mask-x-to": scaleMaskImagePosition() }],
-			"mask-image-x-from-color": [{ "mask-x-from": scaleColor() }],
-			"mask-image-x-to-color": [{ "mask-x-to": scaleColor() }],
-			"mask-image-y-from-pos": [{ "mask-y-from": scaleMaskImagePosition() }],
-			"mask-image-y-to-pos": [{ "mask-y-to": scaleMaskImagePosition() }],
-			"mask-image-y-from-color": [{ "mask-y-from": scaleColor() }],
-			"mask-image-y-to-color": [{ "mask-y-to": scaleColor() }],
-			"mask-image-radial": [{ "mask-radial": [isArbitraryVariable, isArbitraryValue] }],
-			"mask-image-radial-from-pos": [{ "mask-radial-from": scaleMaskImagePosition() }],
-			"mask-image-radial-to-pos": [{ "mask-radial-to": scaleMaskImagePosition() }],
-			"mask-image-radial-from-color": [{ "mask-radial-from": scaleColor() }],
-			"mask-image-radial-to-color": [{ "mask-radial-to": scaleColor() }],
-			"mask-image-radial-shape": [{ "mask-radial": ["circle", "ellipse"] }],
-			"mask-image-radial-size": [{ "mask-radial": [{
-				closest: ["side", "corner"],
-				farthest: ["side", "corner"]
-			}] }],
-			"mask-image-radial-pos": [{ "mask-radial-at": scalePosition() }],
-			"mask-image-conic-pos": [{ "mask-conic": [isNumber] }],
-			"mask-image-conic-from-pos": [{ "mask-conic-from": scaleMaskImagePosition() }],
-			"mask-image-conic-to-pos": [{ "mask-conic-to": scaleMaskImagePosition() }],
-			"mask-image-conic-from-color": [{ "mask-conic-from": scaleColor() }],
-			"mask-image-conic-to-color": [{ "mask-conic-to": scaleColor() }],
-			"mask-mode": [{ mask: [
-				"alpha",
-				"luminance",
-				"match"
-			] }],
-			"mask-origin": [{ "mask-origin": [
-				"border",
-				"padding",
-				"content",
-				"fill",
-				"stroke",
-				"view"
-			] }],
-			"mask-position": [{ mask: scaleBgPosition() }],
-			"mask-repeat": [{ mask: scaleBgRepeat() }],
-			"mask-size": [{ mask: scaleBgSize() }],
-			"mask-type": [{ "mask-type": ["alpha", "luminance"] }],
-			"mask-image": [{ mask: [
-				"none",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			filter: [{ filter: [
-				"",
-				"none",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			blur: [{ blur: scaleBlur() }],
-			brightness: [{ brightness: [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			contrast: [{ contrast: [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"drop-shadow": [{ "drop-shadow": [
-				"",
-				"none",
-				themeDropShadow,
-				isArbitraryVariableShadow,
-				isArbitraryShadow
-			] }],
-			"drop-shadow-color": [{ "drop-shadow": scaleColor() }],
-			grayscale: [{ grayscale: [
-				"",
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"hue-rotate": [{ "hue-rotate": [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			invert: [{ invert: [
-				"",
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			saturate: [{ saturate: [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			sepia: [{ sepia: [
-				"",
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"backdrop-filter": [{ "backdrop-filter": [
-				"",
-				"none",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"backdrop-blur": [{ "backdrop-blur": scaleBlur() }],
-			"backdrop-brightness": [{ "backdrop-brightness": [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"backdrop-contrast": [{ "backdrop-contrast": [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"backdrop-grayscale": [{ "backdrop-grayscale": [
-				"",
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"backdrop-hue-rotate": [{ "backdrop-hue-rotate": [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"backdrop-invert": [{ "backdrop-invert": [
-				"",
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"backdrop-opacity": [{ "backdrop-opacity": [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"backdrop-saturate": [{ "backdrop-saturate": [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"backdrop-sepia": [{ "backdrop-sepia": [
-				"",
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"border-collapse": [{ border: ["collapse", "separate"] }],
-			"border-spacing": [{ "border-spacing": scaleUnambiguousSpacing() }],
-			"border-spacing-x": [{ "border-spacing-x": scaleUnambiguousSpacing() }],
-			"border-spacing-y": [{ "border-spacing-y": scaleUnambiguousSpacing() }],
-			"table-layout": [{ table: ["auto", "fixed"] }],
-			caption: [{ caption: ["top", "bottom"] }],
-			transition: [{ transition: [
-				"",
-				"all",
-				"colors",
-				"opacity",
-				"shadow",
-				"transform",
-				"none",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"transition-behavior": [{ transition: ["normal", "discrete"] }],
-			duration: [{ duration: [
-				isNumber,
-				"initial",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			ease: [{ ease: [
-				"linear",
-				"initial",
-				themeEase,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			delay: [{ delay: [
-				isNumber,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			animate: [{ animate: [
-				"none",
-				themeAnimate,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			backface: [{ backface: ["hidden", "visible"] }],
-			perspective: [{ perspective: [
-				themePerspective,
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"perspective-origin": [{ "perspective-origin": scalePositionWithArbitrary() }],
-			rotate: [{ rotate: scaleRotate() }],
-			"rotate-x": [{ "rotate-x": scaleRotate() }],
-			"rotate-y": [{ "rotate-y": scaleRotate() }],
-			"rotate-z": [{ "rotate-z": scaleRotate() }],
-			scale: [{ scale: scaleScale() }],
-			"scale-x": [{ "scale-x": scaleScale() }],
-			"scale-y": [{ "scale-y": scaleScale() }],
-			"scale-z": [{ "scale-z": scaleScale() }],
-			"scale-3d": ["scale-3d"],
-			skew: [{ skew: scaleSkew() }],
-			"skew-x": [{ "skew-x": scaleSkew() }],
-			"skew-y": [{ "skew-y": scaleSkew() }],
-			transform: [{ transform: [
-				isArbitraryVariable,
-				isArbitraryValue,
-				"",
-				"none",
-				"gpu",
-				"cpu"
-			] }],
-			"transform-origin": [{ origin: scalePositionWithArbitrary() }],
-			"transform-style": [{ transform: ["3d", "flat"] }],
-			translate: [{ translate: scaleTranslate() }],
-			"translate-x": [{ "translate-x": scaleTranslate() }],
-			"translate-y": [{ "translate-y": scaleTranslate() }],
-			"translate-z": [{ "translate-z": scaleTranslate() }],
-			"translate-none": ["translate-none"],
-			accent: [{ accent: scaleColor() }],
-			appearance: [{ appearance: ["none", "auto"] }],
-			"caret-color": [{ caret: scaleColor() }],
-			"color-scheme": [{ scheme: [
-				"normal",
-				"dark",
-				"light",
-				"light-dark",
-				"only-dark",
-				"only-light"
-			] }],
-			cursor: [{ cursor: [
-				"auto",
-				"default",
-				"pointer",
-				"wait",
-				"text",
-				"move",
-				"help",
-				"not-allowed",
-				"none",
-				"context-menu",
-				"progress",
-				"cell",
-				"crosshair",
-				"vertical-text",
-				"alias",
-				"copy",
-				"no-drop",
-				"grab",
-				"grabbing",
-				"all-scroll",
-				"col-resize",
-				"row-resize",
-				"n-resize",
-				"e-resize",
-				"s-resize",
-				"w-resize",
-				"ne-resize",
-				"nw-resize",
-				"se-resize",
-				"sw-resize",
-				"ew-resize",
-				"ns-resize",
-				"nesw-resize",
-				"nwse-resize",
-				"zoom-in",
-				"zoom-out",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			"field-sizing": [{ "field-sizing": ["fixed", "content"] }],
-			"pointer-events": [{ "pointer-events": ["auto", "none"] }],
-			resize: [{ resize: [
-				"none",
-				"",
-				"y",
-				"x"
-			] }],
-			"scroll-behavior": [{ scroll: ["auto", "smooth"] }],
-			"scroll-m": [{ "scroll-m": scaleUnambiguousSpacing() }],
-			"scroll-mx": [{ "scroll-mx": scaleUnambiguousSpacing() }],
-			"scroll-my": [{ "scroll-my": scaleUnambiguousSpacing() }],
-			"scroll-ms": [{ "scroll-ms": scaleUnambiguousSpacing() }],
-			"scroll-me": [{ "scroll-me": scaleUnambiguousSpacing() }],
-			"scroll-mt": [{ "scroll-mt": scaleUnambiguousSpacing() }],
-			"scroll-mr": [{ "scroll-mr": scaleUnambiguousSpacing() }],
-			"scroll-mb": [{ "scroll-mb": scaleUnambiguousSpacing() }],
-			"scroll-ml": [{ "scroll-ml": scaleUnambiguousSpacing() }],
-			"scroll-p": [{ "scroll-p": scaleUnambiguousSpacing() }],
-			"scroll-px": [{ "scroll-px": scaleUnambiguousSpacing() }],
-			"scroll-py": [{ "scroll-py": scaleUnambiguousSpacing() }],
-			"scroll-ps": [{ "scroll-ps": scaleUnambiguousSpacing() }],
-			"scroll-pe": [{ "scroll-pe": scaleUnambiguousSpacing() }],
-			"scroll-pt": [{ "scroll-pt": scaleUnambiguousSpacing() }],
-			"scroll-pr": [{ "scroll-pr": scaleUnambiguousSpacing() }],
-			"scroll-pb": [{ "scroll-pb": scaleUnambiguousSpacing() }],
-			"scroll-pl": [{ "scroll-pl": scaleUnambiguousSpacing() }],
-			"snap-align": [{ snap: [
-				"start",
-				"end",
-				"center",
-				"align-none"
-			] }],
-			"snap-stop": [{ snap: ["normal", "always"] }],
-			"snap-type": [{ snap: [
-				"none",
-				"x",
-				"y",
-				"both"
-			] }],
-			"snap-strictness": [{ snap: ["mandatory", "proximity"] }],
-			touch: [{ touch: [
-				"auto",
-				"none",
-				"manipulation"
-			] }],
-			"touch-x": [{ "touch-pan": [
-				"x",
-				"left",
-				"right"
-			] }],
-			"touch-y": [{ "touch-pan": [
-				"y",
-				"up",
-				"down"
-			] }],
-			"touch-pz": ["touch-pinch-zoom"],
-			select: [{ select: [
-				"none",
-				"text",
-				"all",
-				"auto"
-			] }],
-			"will-change": [{ "will-change": [
-				"auto",
-				"scroll",
-				"contents",
-				"transform",
-				isArbitraryVariable,
-				isArbitraryValue
-			] }],
-			fill: [{ fill: ["none", ...scaleColor()] }],
-			"stroke-w": [{ stroke: [
-				isNumber,
-				isArbitraryVariableLength,
-				isArbitraryLength,
-				isArbitraryNumber
-			] }],
-			stroke: [{ stroke: ["none", ...scaleColor()] }],
-			"forced-color-adjust": [{ "forced-color-adjust": ["auto", "none"] }]
-		},
-		conflictingClassGroups: {
-			overflow: ["overflow-x", "overflow-y"],
-			overscroll: ["overscroll-x", "overscroll-y"],
-			inset: [
-				"inset-x",
-				"inset-y",
-				"start",
-				"end",
-				"top",
-				"right",
-				"bottom",
-				"left"
-			],
-			"inset-x": ["right", "left"],
-			"inset-y": ["top", "bottom"],
-			flex: [
-				"basis",
-				"grow",
-				"shrink"
-			],
-			gap: ["gap-x", "gap-y"],
-			p: [
-				"px",
-				"py",
-				"ps",
-				"pe",
-				"pt",
-				"pr",
-				"pb",
-				"pl"
-			],
-			px: ["pr", "pl"],
-			py: ["pt", "pb"],
-			m: [
-				"mx",
-				"my",
-				"ms",
-				"me",
-				"mt",
-				"mr",
-				"mb",
-				"ml"
-			],
-			mx: ["mr", "ml"],
-			my: ["mt", "mb"],
-			size: ["w", "h"],
-			"font-size": ["leading"],
-			"fvn-normal": [
-				"fvn-ordinal",
-				"fvn-slashed-zero",
-				"fvn-figure",
-				"fvn-spacing",
-				"fvn-fraction"
-			],
-			"fvn-ordinal": ["fvn-normal"],
-			"fvn-slashed-zero": ["fvn-normal"],
-			"fvn-figure": ["fvn-normal"],
-			"fvn-spacing": ["fvn-normal"],
-			"fvn-fraction": ["fvn-normal"],
-			"line-clamp": ["display", "overflow"],
-			rounded: [
-				"rounded-s",
-				"rounded-e",
-				"rounded-t",
-				"rounded-r",
-				"rounded-b",
-				"rounded-l",
-				"rounded-ss",
-				"rounded-se",
-				"rounded-ee",
-				"rounded-es",
-				"rounded-tl",
-				"rounded-tr",
-				"rounded-br",
-				"rounded-bl"
-			],
-			"rounded-s": ["rounded-ss", "rounded-es"],
-			"rounded-e": ["rounded-se", "rounded-ee"],
-			"rounded-t": ["rounded-tl", "rounded-tr"],
-			"rounded-r": ["rounded-tr", "rounded-br"],
-			"rounded-b": ["rounded-br", "rounded-bl"],
-			"rounded-l": ["rounded-tl", "rounded-bl"],
-			"border-spacing": ["border-spacing-x", "border-spacing-y"],
-			"border-w": [
-				"border-w-x",
-				"border-w-y",
-				"border-w-s",
-				"border-w-e",
-				"border-w-t",
-				"border-w-r",
-				"border-w-b",
-				"border-w-l"
-			],
-			"border-w-x": ["border-w-r", "border-w-l"],
-			"border-w-y": ["border-w-t", "border-w-b"],
-			"border-color": [
-				"border-color-x",
-				"border-color-y",
-				"border-color-s",
-				"border-color-e",
-				"border-color-t",
-				"border-color-r",
-				"border-color-b",
-				"border-color-l"
-			],
-			"border-color-x": ["border-color-r", "border-color-l"],
-			"border-color-y": ["border-color-t", "border-color-b"],
-			translate: [
-				"translate-x",
-				"translate-y",
-				"translate-none"
-			],
-			"translate-none": [
-				"translate",
-				"translate-x",
-				"translate-y",
-				"translate-z"
-			],
-			"scroll-m": [
-				"scroll-mx",
-				"scroll-my",
-				"scroll-ms",
-				"scroll-me",
-				"scroll-mt",
-				"scroll-mr",
-				"scroll-mb",
-				"scroll-ml"
-			],
-			"scroll-mx": ["scroll-mr", "scroll-ml"],
-			"scroll-my": ["scroll-mt", "scroll-mb"],
-			"scroll-p": [
-				"scroll-px",
-				"scroll-py",
-				"scroll-ps",
-				"scroll-pe",
-				"scroll-pt",
-				"scroll-pr",
-				"scroll-pb",
-				"scroll-pl"
-			],
-			"scroll-px": ["scroll-pr", "scroll-pl"],
-			"scroll-py": ["scroll-pt", "scroll-pb"],
-			touch: [
-				"touch-x",
-				"touch-y",
-				"touch-pz"
-			],
-			"touch-x": ["touch"],
-			"touch-y": ["touch"],
-			"touch-pz": ["touch"]
-		},
-		conflictingClassGroupModifiers: { "font-size": ["leading"] },
-		orderSensitiveModifiers: [
-			"*",
-			"**",
-			"after",
-			"backdrop",
-			"before",
-			"details-content",
-			"file",
-			"first-letter",
-			"first-line",
-			"marker",
-			"placeholder",
-			"selection"
-		]
-	};
-};
-var twMerge = /* @__PURE__ */ createTailwindMerge(getDefaultConfig);
-function cn(...inputs) {
-	return twMerge(clsx(inputs));
-}
-var buttonVariants = cva("inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive", {
-	variants: {
-		variant: {
-			default: "bg-primary text-primary-foreground shadow-xs hover:bg-primary/90",
-			destructive: "bg-destructive text-white shadow-xs hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
-			outline: "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
-			secondary: "bg-secondary text-secondary-foreground shadow-xs hover:bg-secondary/80",
-			ghost: "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
-			link: "text-primary underline-offset-4 hover:underline"
-		},
-		size: {
-			default: "h-9 px-4 py-2 has-[>svg]:px-3",
-			sm: "h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",
-			lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
-			icon: "size-9"
-		}
-	},
-	defaultVariants: {
-		variant: "default",
-		size: "default"
-	}
-});
-function Button({ className, variant, size, asChild = false, ...props }) {
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(asChild ? Slot$1 : "button", {
-		"data-slot": "button",
-		className: cn(buttonVariants({
-			variant,
-			size,
-			className
-		})),
-		...props
-	});
-}
-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);
-	};
-}
-function createContext2(rootComponentName, defaultContext) {
-	const Context = react__WEBPACK_IMPORTED_MODULE_0__.createContext(defaultContext);
-	const Provider = (props) => {
-		const { children, ...context } = props;
-		const value = react__WEBPACK_IMPORTED_MODULE_0__.useMemo(() => context, Object.values(context));
-		return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Context.Provider, {
-			value,
-			children
-		});
-	};
-	Provider.displayName = rootComponentName + "Provider";
-	function useContext2(consumerName) {
-		const context = react__WEBPACK_IMPORTED_MODULE_0__.useContext(Context);
-		if (context) return context;
-		if (defaultContext !== void 0) return defaultContext;
-		throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
-	}
-	return [Provider, useContext2];
-}
-function createContextScope(scopeName, createContextScopeDeps = []) {
-	let defaultContexts = [];
-	function createContext3(rootComponentName, defaultContext) {
-		const BaseContext = react__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.useMemo(() => context, Object.values(context));
-			return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Context.Provider, {
-				value,
-				children
-			});
-		};
-		Provider.displayName = rootComponentName + "Provider";
-		function useContext2(consumerName, scope) {
-			const Context = scope?.[scopeName]?.[index] || BaseContext;
-			const context = react__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.createContext(defaultContext);
-		});
-		return function useScope(scope) {
-			const contexts = scope?.[scopeName] || scopeContexts;
-			return react__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
-		};
-	};
-	createScope.scopeName = baseScope.scopeName;
-	return createScope;
-}
-var useLayoutEffect2 = globalThis?.document ? react__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect : () => {};
-var useReactId = /*#__PURE__*/ (react__WEBPACK_IMPORTED_MODULE_0___namespace_cache || (react__WEBPACK_IMPORTED_MODULE_0___namespace_cache = __webpack_require__.t(react__WEBPACK_IMPORTED_MODULE_0__, 2)))[" useId ".trim().toString()] || (() => void 0);
-var count$1 = 0;
-function useId(deterministicId) {
-	const [id, setId] = react__WEBPACK_IMPORTED_MODULE_0__.useState(useReactId());
-	useLayoutEffect2(() => {
-		if (!deterministicId) setId((reactId) => reactId ?? String(count$1++));
-	}, [deterministicId]);
-	return deterministicId || (id ? `radix-${id}` : "");
-}
-var useInsertionEffect = /*#__PURE__*/ (react__WEBPACK_IMPORTED_MODULE_0___namespace_cache || (react__WEBPACK_IMPORTED_MODULE_0___namespace_cache = __webpack_require__.t(react__WEBPACK_IMPORTED_MODULE_0__, 2)))[" 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__WEBPACK_IMPORTED_MODULE_0__.useRef(prop !== void 0);
-		react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-			const wasControlled = isControlledRef.current;
-			if (wasControlled !== isControlled) {
-				const from = wasControlled ? "controlled" : "uncontrolled";
-				const to = isControlled ? "controlled" : "uncontrolled";
-				console.warn(`${caller} is changing from ${from} to ${to}. 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__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.useState(defaultProp);
-	const prevValueRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(value);
-	const onChangeRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(onChange);
-	useInsertionEffect(() => {
-		onChangeRef.current = onChange;
-	}, [onChange]);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		if (prevValueRef.current !== value) {
-			onChangeRef.current?.(value);
-			prevValueRef.current = value;
-		}
-	}, [value, prevValueRef]);
-	return [
-		value,
-		setValue,
-		onChangeRef
-	];
-}
-function isFunction(value) {
-	return typeof value === "function";
-}
-var Primitive = [
-	"a",
-	"button",
-	"div",
-	"form",
-	"h2",
-	"h3",
-	"img",
-	"input",
-	"label",
-	"li",
-	"nav",
-	"ol",
-	"p",
-	"select",
-	"span",
-	"svg",
-	"ul"
-].reduce((primitive, node) => {
-	const Slot$2 = /* @__PURE__ */ createSlot(`Primitive.${node}`);
-	const Node$1 = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-		const { asChild, ...primitiveProps } = props;
-		const Comp = asChild ? Slot$2 : node;
-		if (typeof window !== "undefined") window[Symbol.for("radix-ui")] = true;
-		return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Comp, {
-			...primitiveProps,
-			ref: forwardedRef
-		});
-	});
-	Node$1.displayName = `Primitive.${node}`;
-	return {
-		...primitive,
-		[node]: Node$1
-	};
-}, {});
-function dispatchDiscreteCustomEvent(target, event) {
-	if (target) react_dom__WEBPACK_IMPORTED_MODULE_3__.flushSync(() => target.dispatchEvent(event));
-}
-function useCallbackRef$1(callback) {
-	const callbackRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(callback);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		callbackRef.current = callback;
-	});
-	return react__WEBPACK_IMPORTED_MODULE_0__.useMemo(() => (...args) => callbackRef.current?.(...args), []);
-}
-function useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis?.document) {
-	const onEscapeKeyDown = useCallbackRef$1(onEscapeKeyDownProp);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		const handleKeyDown = (event) => {
-			if (event.key === "Escape") onEscapeKeyDown(event);
-		};
-		ownerDocument.addEventListener("keydown", handleKeyDown, { capture: true });
-		return () => ownerDocument.removeEventListener("keydown", handleKeyDown, { capture: true });
-	}, [onEscapeKeyDown, ownerDocument]);
-}
-var DISMISSABLE_LAYER_NAME = "DismissableLayer";
-var CONTEXT_UPDATE = "dismissableLayer.update";
-var POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
-var FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
-var originalBodyPointerEvents;
-var DismissableLayerContext = react__WEBPACK_IMPORTED_MODULE_0__.createContext({
-	layers: /* @__PURE__ */ new Set(),
-	layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
-	branches: /* @__PURE__ */ new Set()
-});
-var DismissableLayer = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const { disableOutsidePointerEvents = false, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, onDismiss, ...layerProps } = props;
-	const context = react__WEBPACK_IMPORTED_MODULE_0__.useContext(DismissableLayerContext);
-	const [node, setNode] = react__WEBPACK_IMPORTED_MODULE_0__.useState(null);
-	const ownerDocument = node?.ownerDocument ?? globalThis?.document;
-	const [, force] = react__WEBPACK_IMPORTED_MODULE_0__.useState({});
-	const composedRefs = useComposedRefs(forwardedRef, (node2) => setNode(node2));
-	const layers = Array.from(context.layers);
-	const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1);
-	const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled);
-	const index = node ? layers.indexOf(node) : -1;
-	const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;
-	const isPointerEventsEnabled = index >= highestLayerWithOutsidePointerEventsDisabledIndex;
-	const pointerDownOutside = usePointerDownOutside((event) => {
-		const target = event.target;
-		const isPointerDownOnBranch = [...context.branches].some((branch) => branch.contains(target));
-		if (!isPointerEventsEnabled || isPointerDownOnBranch) return;
-		onPointerDownOutside?.(event);
-		onInteractOutside?.(event);
-		if (!event.defaultPrevented) onDismiss?.();
-	}, ownerDocument);
-	const focusOutside = useFocusOutside((event) => {
-		const target = event.target;
-		if ([...context.branches].some((branch) => branch.contains(target))) return;
-		onFocusOutside?.(event);
-		onInteractOutside?.(event);
-		if (!event.defaultPrevented) onDismiss?.();
-	}, ownerDocument);
-	useEscapeKeydown((event) => {
-		if (!(index === context.layers.size - 1)) return;
-		onEscapeKeyDown?.(event);
-		if (!event.defaultPrevented && onDismiss) {
-			event.preventDefault();
-			onDismiss();
-		}
-	}, ownerDocument);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		if (!node) return;
-		if (disableOutsidePointerEvents) {
-			if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
-				originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;
-				ownerDocument.body.style.pointerEvents = "none";
-			}
-			context.layersWithOutsidePointerEventsDisabled.add(node);
-		}
-		context.layers.add(node);
-		dispatchUpdate();
-		return () => {
-			if (disableOutsidePointerEvents && context.layersWithOutsidePointerEventsDisabled.size === 1) ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;
-		};
-	}, [
-		node,
-		ownerDocument,
-		disableOutsidePointerEvents,
-		context
-	]);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		return () => {
-			if (!node) return;
-			context.layers.delete(node);
-			context.layersWithOutsidePointerEventsDisabled.delete(node);
-			dispatchUpdate();
-		};
-	}, [node, context]);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		const handleUpdate = () => force({});
-		document.addEventListener(CONTEXT_UPDATE, handleUpdate);
-		return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);
-	}, []);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Primitive.div, {
-		...layerProps,
-		ref: composedRefs,
-		style: {
-			pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? "auto" : "none" : void 0,
-			...props.style
-		},
-		onFocusCapture: composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture),
-		onBlurCapture: composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture),
-		onPointerDownCapture: composeEventHandlers(props.onPointerDownCapture, pointerDownOutside.onPointerDownCapture)
-	});
-});
-DismissableLayer.displayName = DISMISSABLE_LAYER_NAME;
-var BRANCH_NAME = "DismissableLayerBranch";
-var DismissableLayerBranch = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const context = react__WEBPACK_IMPORTED_MODULE_0__.useContext(DismissableLayerContext);
-	const ref = react__WEBPACK_IMPORTED_MODULE_0__.useRef(null);
-	const composedRefs = useComposedRefs(forwardedRef, ref);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		const node = ref.current;
-		if (node) {
-			context.branches.add(node);
-			return () => {
-				context.branches.delete(node);
-			};
-		}
-	}, [context.branches]);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Primitive.div, {
-		...props,
-		ref: composedRefs
-	});
-});
-DismissableLayerBranch.displayName = BRANCH_NAME;
-function usePointerDownOutside(onPointerDownOutside, ownerDocument = globalThis?.document) {
-	const handlePointerDownOutside = useCallbackRef$1(onPointerDownOutside);
-	const isPointerInsideReactTreeRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(false);
-	const handleClickRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(() => {});
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		const handlePointerDown = (event) => {
-			if (event.target && !isPointerInsideReactTreeRef.current) {
-				let handleAndDispatchPointerDownOutsideEvent2 = function() {
-					handleAndDispatchCustomEvent(POINTER_DOWN_OUTSIDE, handlePointerDownOutside, eventDetail, { discrete: true });
-				};
-				const eventDetail = { originalEvent: event };
-				if (event.pointerType === "touch") {
-					ownerDocument.removeEventListener("click", handleClickRef.current);
-					handleClickRef.current = handleAndDispatchPointerDownOutsideEvent2;
-					ownerDocument.addEventListener("click", handleClickRef.current, { once: true });
-				} else handleAndDispatchPointerDownOutsideEvent2();
-			} else ownerDocument.removeEventListener("click", handleClickRef.current);
-			isPointerInsideReactTreeRef.current = false;
-		};
-		const timerId = window.setTimeout(() => {
-			ownerDocument.addEventListener("pointerdown", handlePointerDown);
-		}, 0);
-		return () => {
-			window.clearTimeout(timerId);
-			ownerDocument.removeEventListener("pointerdown", handlePointerDown);
-			ownerDocument.removeEventListener("click", handleClickRef.current);
-		};
-	}, [ownerDocument, handlePointerDownOutside]);
-	return { onPointerDownCapture: () => isPointerInsideReactTreeRef.current = true };
-}
-function useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {
-	const handleFocusOutside = useCallbackRef$1(onFocusOutside);
-	const isFocusInsideReactTreeRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(false);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		const handleFocus = (event) => {
-			if (event.target && !isFocusInsideReactTreeRef.current) handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, { originalEvent: event }, { discrete: false });
-		};
-		ownerDocument.addEventListener("focusin", handleFocus);
-		return () => ownerDocument.removeEventListener("focusin", handleFocus);
-	}, [ownerDocument, handleFocusOutside]);
-	return {
-		onFocusCapture: () => isFocusInsideReactTreeRef.current = true,
-		onBlurCapture: () => isFocusInsideReactTreeRef.current = false
-	};
-}
-function dispatchUpdate() {
-	const event = new CustomEvent(CONTEXT_UPDATE);
-	document.dispatchEvent(event);
-}
-function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
-	const target = detail.originalEvent.target;
-	const event = new CustomEvent(name, {
-		bubbles: false,
-		cancelable: true,
-		detail
-	});
-	if (handler) target.addEventListener(name, handler, { once: true });
-	if (discrete) dispatchDiscreteCustomEvent(target, event);
-	else target.dispatchEvent(event);
-}
-var AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
-var AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
-var EVENT_OPTIONS = {
-	bubbles: false,
-	cancelable: true
-};
-var FOCUS_SCOPE_NAME = "FocusScope";
-var FocusScope = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const { loop = false, trapped = false, onMountAutoFocus: onMountAutoFocusProp, onUnmountAutoFocus: onUnmountAutoFocusProp, ...scopeProps } = props;
-	const [container, setContainer] = react__WEBPACK_IMPORTED_MODULE_0__.useState(null);
-	const onMountAutoFocus = useCallbackRef$1(onMountAutoFocusProp);
-	const onUnmountAutoFocus = useCallbackRef$1(onUnmountAutoFocusProp);
-	const lastFocusedElementRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(null);
-	const composedRefs = useComposedRefs(forwardedRef, (node) => setContainer(node));
-	const focusScope = react__WEBPACK_IMPORTED_MODULE_0__.useRef({
-		paused: false,
-		pause() {
-			this.paused = true;
-		},
-		resume() {
-			this.paused = false;
-		}
-	}).current;
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		if (trapped) {
-			let handleFocusIn2 = function(event) {
-				if (focusScope.paused || !container) return;
-				const target = event.target;
-				if (container.contains(target)) lastFocusedElementRef.current = target;
-				else focus(lastFocusedElementRef.current, { select: true });
-			}, handleFocusOut2 = function(event) {
-				if (focusScope.paused || !container) return;
-				const relatedTarget = event.relatedTarget;
-				if (relatedTarget === null) return;
-				if (!container.contains(relatedTarget)) focus(lastFocusedElementRef.current, { select: true });
-			}, handleMutations2 = function(mutations) {
-				if (document.activeElement !== document.body) return;
-				for (const mutation of mutations) if (mutation.removedNodes.length > 0) focus(container);
-			};
-			document.addEventListener("focusin", handleFocusIn2);
-			document.addEventListener("focusout", handleFocusOut2);
-			const mutationObserver = new MutationObserver(handleMutations2);
-			if (container) mutationObserver.observe(container, {
-				childList: true,
-				subtree: true
-			});
-			return () => {
-				document.removeEventListener("focusin", handleFocusIn2);
-				document.removeEventListener("focusout", handleFocusOut2);
-				mutationObserver.disconnect();
-			};
-		}
-	}, [
-		trapped,
-		container,
-		focusScope.paused
-	]);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		if (container) {
-			focusScopesStack.add(focusScope);
-			const previouslyFocusedElement = document.activeElement;
-			if (!container.contains(previouslyFocusedElement)) {
-				const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
-				container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
-				container.dispatchEvent(mountEvent);
-				if (!mountEvent.defaultPrevented) {
-					focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });
-					if (document.activeElement === previouslyFocusedElement) focus(container);
-				}
-			}
-			return () => {
-				container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
-				setTimeout(() => {
-					const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
-					container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
-					container.dispatchEvent(unmountEvent);
-					if (!unmountEvent.defaultPrevented) focus(previouslyFocusedElement ?? document.body, { select: true });
-					container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
-					focusScopesStack.remove(focusScope);
-				}, 0);
-			};
-		}
-	}, [
-		container,
-		onMountAutoFocus,
-		onUnmountAutoFocus,
-		focusScope
-	]);
-	const handleKeyDown = react__WEBPACK_IMPORTED_MODULE_0__.useCallback((event) => {
-		if (!loop && !trapped) return;
-		if (focusScope.paused) return;
-		const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
-		const focusedElement = document.activeElement;
-		if (isTabKey && focusedElement) {
-			const container2 = event.currentTarget;
-			const [first, last] = getTabbableEdges(container2);
-			if (!(first && last)) {
-				if (focusedElement === container2) event.preventDefault();
-			} else if (!event.shiftKey && focusedElement === last) {
-				event.preventDefault();
-				if (loop) focus(first, { select: true });
-			} else if (event.shiftKey && focusedElement === first) {
-				event.preventDefault();
-				if (loop) focus(last, { select: true });
-			}
-		}
-	}, [
-		loop,
-		trapped,
-		focusScope.paused
-	]);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Primitive.div, {
-		tabIndex: -1,
-		...scopeProps,
-		ref: composedRefs,
-		onKeyDown: handleKeyDown
-	});
-});
-FocusScope.displayName = FOCUS_SCOPE_NAME;
-function focusFirst(candidates, { select = false } = {}) {
-	const previouslyFocusedElement = document.activeElement;
-	for (const candidate of candidates) {
-		focus(candidate, { select });
-		if (document.activeElement !== previouslyFocusedElement) return;
-	}
-}
-function getTabbableEdges(container) {
-	const candidates = getTabbableCandidates(container);
-	return [findVisible(candidates, container), findVisible(candidates.reverse(), container)];
-}
-function getTabbableCandidates(container) {
-	const nodes = [];
-	const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, { acceptNode: (node) => {
-		const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
-		if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
-		return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
-	} });
-	while (walker.nextNode()) nodes.push(walker.currentNode);
-	return nodes;
-}
-function findVisible(elements, container) {
-	for (const element of elements) if (!isHidden(element, { upTo: container })) return element;
-}
-function isHidden(node, { upTo }) {
-	if (getComputedStyle(node).visibility === "hidden") return true;
-	while (node) {
-		if (upTo !== void 0 && node === upTo) return false;
-		if (getComputedStyle(node).display === "none") return true;
-		node = node.parentElement;
-	}
-	return false;
-}
-function isSelectableInput(element) {
-	return element instanceof HTMLInputElement && "select" in element;
-}
-function focus(element, { select = false } = {}) {
-	if (element && element.focus) {
-		const previouslyFocusedElement = document.activeElement;
-		element.focus({ preventScroll: true });
-		if (element !== previouslyFocusedElement && isSelectableInput(element) && select) element.select();
-	}
-}
-var focusScopesStack = createFocusScopesStack();
-function createFocusScopesStack() {
-	let stack = [];
-	return {
-		add(focusScope) {
-			const activeFocusScope = stack[0];
-			if (focusScope !== activeFocusScope) activeFocusScope?.pause();
-			stack = arrayRemove(stack, focusScope);
-			stack.unshift(focusScope);
-		},
-		remove(focusScope) {
-			stack = arrayRemove(stack, focusScope);
-			stack[0]?.resume();
-		}
-	};
-}
-function arrayRemove(array, item) {
-	const updatedArray = [...array];
-	const index = updatedArray.indexOf(item);
-	if (index !== -1) updatedArray.splice(index, 1);
-	return updatedArray;
-}
-function removeLinks(items) {
-	return items.filter((item) => item.tagName !== "A");
-}
-var PORTAL_NAME$1 = "Portal";
-var Portal = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const { container: containerProp, ...portalProps } = props;
-	const [mounted, setMounted] = react__WEBPACK_IMPORTED_MODULE_0__.useState(false);
-	useLayoutEffect2(() => setMounted(true), []);
-	const container = containerProp || mounted && globalThis?.document?.body;
-	return container ? react_dom__WEBPACK_IMPORTED_MODULE_3__.createPortal(/* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Primitive.div, {
-		...portalProps,
-		ref: forwardedRef
-	}), container) : null;
-});
-Portal.displayName = PORTAL_NAME$1;
-function useStateMachine(initialState, machine) {
-	return react__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.Children.only(children);
-	const ref = useComposedRefs(presence.ref, getElementRef(child));
-	return typeof children === "function" || presence.isPresent ? react__WEBPACK_IMPORTED_MODULE_0__.cloneElement(child, { ref }) : null;
-};
-Presence.displayName = "Presence";
-function usePresence(present) {
-	const [node, setNode] = react__WEBPACK_IMPORTED_MODULE_0__.useState();
-	const stylesRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(null);
-	const prevPresentRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(present);
-	const prevAnimationNameRef = react__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.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__WEBPACK_IMPORTED_MODULE_0__.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;
-}
-var count = 0;
-function useFocusGuards() {
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		const edgeGuards = document.querySelectorAll("[data-radix-focus-guard]");
-		document.body.insertAdjacentElement("afterbegin", edgeGuards[0] ?? createFocusGuard());
-		document.body.insertAdjacentElement("beforeend", edgeGuards[1] ?? createFocusGuard());
-		count++;
-		return () => {
-			if (count === 1) document.querySelectorAll("[data-radix-focus-guard]").forEach((node) => node.remove());
-			count--;
-		};
-	}, []);
-}
-function createFocusGuard() {
-	const element = document.createElement("span");
-	element.setAttribute("data-radix-focus-guard", "");
-	element.tabIndex = 0;
-	element.style.outline = "none";
-	element.style.opacity = "0";
-	element.style.position = "fixed";
-	element.style.pointerEvents = "none";
-	return element;
-}
-var __assign = function() {
-	__assign = Object.assign || function __assign$1(t) {
-		for (var s, i = 1, n = arguments.length; i < n; i++) {
-			s = arguments[i];
-			for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-		}
-		return t;
-	};
-	return __assign.apply(this, arguments);
-};
-function __rest(s, e) {
-	var t = {};
-	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-	if (s != null && typeof Object.getOwnPropertySymbols === "function") {
-		for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-	}
-	return t;
-}
-function __spreadArray(to, from, pack) {
-	if (pack || arguments.length === 2) {
-		for (var i = 0, l = from.length, ar; i < l; i++) if (ar || !(i in from)) {
-			if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-			ar[i] = from[i];
-		}
-	}
-	return to.concat(ar || Array.prototype.slice.call(from));
-}
-var zeroRightClassName = "right-scroll-bar-position";
-var fullWidthClassName = "width-before-scroll-bar";
-var noScrollbarsClassName = "with-scroll-bars-hidden";
-var removedBarSizeVariable = "--removed-body-scroll-bar-size";
-function assignRef(ref, value) {
-	if (typeof ref === "function") ref(value);
-	else if (ref) ref.current = value;
-	return ref;
-}
-function useCallbackRef(initialValue, callback) {
-	var ref = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(function() {
-		return {
-			value: initialValue,
-			callback,
-			facade: {
-				get current() {
-					return ref.value;
-				},
-				set current(value) {
-					var last = ref.value;
-					if (last !== value) {
-						ref.value = value;
-						ref.callback(value, last);
-					}
-				}
-			}
-		};
-	})[0];
-	ref.callback = callback;
-	return ref.facade;
-}
-var useIsomorphicLayoutEffect = typeof window !== "undefined" ? react__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect : react__WEBPACK_IMPORTED_MODULE_0__.useEffect;
-var currentValues = /* @__PURE__ */ new WeakMap();
-function useMergeRefs(refs, defaultValue) {
-	var callbackRef = useCallbackRef(defaultValue || null, function(newValue) {
-		return refs.forEach(function(ref) {
-			return assignRef(ref, newValue);
-		});
-	});
-	useIsomorphicLayoutEffect(function() {
-		var oldValue = currentValues.get(callbackRef);
-		if (oldValue) {
-			var prevRefs_1 = new Set(oldValue);
-			var nextRefs_1 = new Set(refs);
-			var current_1 = callbackRef.current;
-			prevRefs_1.forEach(function(ref) {
-				if (!nextRefs_1.has(ref)) assignRef(ref, null);
-			});
-			nextRefs_1.forEach(function(ref) {
-				if (!prevRefs_1.has(ref)) assignRef(ref, current_1);
-			});
-		}
-		currentValues.set(callbackRef, refs);
-	}, [refs]);
-	return callbackRef;
-}
-function ItoI(a) {
-	return a;
-}
-function innerCreateMedium(defaults, middleware) {
-	if (middleware === void 0) middleware = ItoI;
-	var buffer = [];
-	var assigned = false;
-	return {
-		read: function() {
-			if (assigned) throw new Error("Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.");
-			if (buffer.length) return buffer[buffer.length - 1];
-			return defaults;
-		},
-		useMedium: function(data) {
-			var item = middleware(data, assigned);
-			buffer.push(item);
-			return function() {
-				buffer = buffer.filter(function(x) {
-					return x !== item;
-				});
-			};
-		},
-		assignSyncMedium: function(cb) {
-			assigned = true;
-			while (buffer.length) {
-				var cbs = buffer;
-				buffer = [];
-				cbs.forEach(cb);
-			}
-			buffer = {
-				push: function(x) {
-					return cb(x);
-				},
-				filter: function() {
-					return buffer;
-				}
-			};
-		},
-		assignMedium: function(cb) {
-			assigned = true;
-			var pendingQueue = [];
-			if (buffer.length) {
-				var cbs = buffer;
-				buffer = [];
-				cbs.forEach(cb);
-				pendingQueue = buffer;
-			}
-			var executeQueue = function() {
-				var cbs$1 = pendingQueue;
-				pendingQueue = [];
-				cbs$1.forEach(cb);
-			};
-			var cycle = function() {
-				return Promise.resolve().then(executeQueue);
-			};
-			cycle();
-			buffer = {
-				push: function(x) {
-					pendingQueue.push(x);
-					cycle();
-				},
-				filter: function(filter) {
-					pendingQueue = pendingQueue.filter(filter);
-					return buffer;
-				}
-			};
-		}
-	};
-}
-function createSidecarMedium(options$1) {
-	if (options$1 === void 0) options$1 = {};
-	var medium = innerCreateMedium(null);
-	medium.options = __assign({
-		async: true,
-		ssr: false
-	}, options$1);
-	return medium;
-}
-var SideCar = function(_a) {
-	var sideCar = _a.sideCar, rest = __rest(_a, ["sideCar"]);
-	if (!sideCar) throw new Error("Sidecar: please provide `sideCar` property to import the right car");
-	var Target = sideCar.read();
-	if (!Target) throw new Error("Sidecar medium not found");
-	return react__WEBPACK_IMPORTED_MODULE_0__.createElement(Target, __assign({}, rest));
-};
-SideCar.isSideCarExport = true;
-function exportSidecar(medium, exported) {
-	medium.useMedium(exported);
-	return SideCar;
-}
-var effectCar = createSidecarMedium();
-var nothing = function() {};
-var RemoveScroll = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(function(props, parentRef) {
-	var ref = react__WEBPACK_IMPORTED_MODULE_0__.useRef(null);
-	var _a = react__WEBPACK_IMPORTED_MODULE_0__.useState({
-		onScrollCapture: nothing,
-		onWheelCapture: nothing,
-		onTouchMoveCapture: nothing
-	}), callbacks = _a[0], setCallbacks = _a[1];
-	var forwardProps = props.forwardProps, children = props.children, className = props.className, removeScrollBar = props.removeScrollBar, enabled = props.enabled, shards = props.shards, sideCar = props.sideCar, noRelative = props.noRelative, noIsolation = props.noIsolation, inert = props.inert, allowPinchZoom = props.allowPinchZoom, _b = props.as, Container = _b === void 0 ? "div" : _b, gapMode = props.gapMode, rest = __rest(props, [
-		"forwardProps",
-		"children",
-		"className",
-		"removeScrollBar",
-		"enabled",
-		"shards",
-		"sideCar",
-		"noRelative",
-		"noIsolation",
-		"inert",
-		"allowPinchZoom",
-		"as",
-		"gapMode"
-	]);
-	var SideCar$1 = sideCar;
-	var containerRef = useMergeRefs([ref, parentRef]);
-	var containerProps = __assign(__assign({}, rest), callbacks);
-	return react__WEBPACK_IMPORTED_MODULE_0__.createElement(react__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, enabled && react__WEBPACK_IMPORTED_MODULE_0__.createElement(SideCar$1, {
-		sideCar: effectCar,
-		removeScrollBar,
-		shards,
-		noRelative,
-		noIsolation,
-		inert,
-		setCallbacks,
-		allowPinchZoom: !!allowPinchZoom,
-		lockRef: ref,
-		gapMode
-	}), forwardProps ? react__WEBPACK_IMPORTED_MODULE_0__.cloneElement(react__WEBPACK_IMPORTED_MODULE_0__.Children.only(children), __assign(__assign({}, containerProps), { ref: containerRef })) : react__WEBPACK_IMPORTED_MODULE_0__.createElement(Container, __assign({}, containerProps, {
-		className,
-		ref: containerRef
-	}), children));
-});
-RemoveScroll.defaultProps = {
-	enabled: true,
-	removeScrollBar: true,
-	inert: false
-};
-RemoveScroll.classNames = {
-	fullWidth: fullWidthClassName,
-	zeroRight: zeroRightClassName
-};
-var currentNonce;
-var getNonce = function() {
-	if (currentNonce) return currentNonce;
-	if (true) return __webpack_require__.nc;
-};
-function makeStyleTag() {
-	if (!document) return null;
-	var tag = document.createElement("style");
-	tag.type = "text/css";
-	var nonce = getNonce();
-	if (nonce) tag.setAttribute("nonce", nonce);
-	return tag;
-}
-function injectStyles(tag, css) {
-	if (tag.styleSheet) tag.styleSheet.cssText = css;
-	else tag.appendChild(document.createTextNode(css));
-}
-function insertStyleTag(tag) {
-	(document.head || document.getElementsByTagName("head")[0]).appendChild(tag);
-}
-var stylesheetSingleton = function() {
-	var counter = 0;
-	var stylesheet = null;
-	return {
-		add: function(style) {
-			if (counter == 0) {
-				if (stylesheet = makeStyleTag()) {
-					injectStyles(stylesheet, style);
-					insertStyleTag(stylesheet);
-				}
-			}
-			counter++;
-		},
-		remove: function() {
-			counter--;
-			if (!counter && stylesheet) {
-				stylesheet.parentNode && stylesheet.parentNode.removeChild(stylesheet);
-				stylesheet = null;
-			}
-		}
-	};
-};
-var styleHookSingleton = function() {
-	var sheet = stylesheetSingleton();
-	return function(styles, isDynamic) {
-		react__WEBPACK_IMPORTED_MODULE_0__.useEffect(function() {
-			sheet.add(styles);
-			return function() {
-				sheet.remove();
-			};
-		}, [styles && isDynamic]);
-	};
-};
-var styleSingleton = function() {
-	var useStyle = styleHookSingleton();
-	var Sheet = function(_a) {
-		var styles = _a.styles, dynamic = _a.dynamic;
-		useStyle(styles, dynamic);
-		return null;
-	};
-	return Sheet;
-};
-var zeroGap = {
-	left: 0,
-	top: 0,
-	right: 0,
-	gap: 0
-};
-var parse = function(x) {
-	return parseInt(x || "", 10) || 0;
-};
-var getOffset = function(gapMode) {
-	var cs = window.getComputedStyle(document.body);
-	var left = cs[gapMode === "padding" ? "paddingLeft" : "marginLeft"];
-	var top = cs[gapMode === "padding" ? "paddingTop" : "marginTop"];
-	var right = cs[gapMode === "padding" ? "paddingRight" : "marginRight"];
-	return [
-		parse(left),
-		parse(top),
-		parse(right)
-	];
-};
-var getGapWidth = function(gapMode) {
-	if (gapMode === void 0) gapMode = "margin";
-	if (typeof window === "undefined") return zeroGap;
-	var offsets = getOffset(gapMode);
-	var documentWidth = document.documentElement.clientWidth;
-	var windowWidth = window.innerWidth;
-	return {
-		left: offsets[0],
-		top: offsets[1],
-		right: offsets[2],
-		gap: Math.max(0, windowWidth - documentWidth + offsets[2] - offsets[0])
-	};
-};
-var Style = styleSingleton();
-var lockAttribute = "data-scroll-locked";
-var getStyles = function(_a, allowRelative, gapMode, important) {
-	var left = _a.left, top = _a.top, right = _a.right, gap = _a.gap;
-	if (gapMode === void 0) gapMode = "margin";
-	return "\n  .".concat(noScrollbarsClassName, " {\n   overflow: hidden ").concat(important, ";\n   padding-right: ").concat(gap, "px ").concat(important, ";\n  }\n  body[").concat(lockAttribute, "] {\n    overflow: hidden ").concat(important, ";\n    overscroll-behavior: contain;\n    ").concat([
-		allowRelative && "position: relative ".concat(important, ";"),
-		gapMode === "margin" && "\n    padding-left: ".concat(left, "px;\n    padding-top: ").concat(top, "px;\n    padding-right: ").concat(right, "px;\n    margin-left:0;\n    margin-top:0;\n    margin-right: ").concat(gap, "px ").concat(important, ";\n    "),
-		gapMode === "padding" && "padding-right: ".concat(gap, "px ").concat(important, ";")
-	].filter(Boolean).join(""), "\n  }\n  \n  .").concat(zeroRightClassName, " {\n    right: ").concat(gap, "px ").concat(important, ";\n  }\n  \n  .").concat(fullWidthClassName, " {\n    margin-right: ").concat(gap, "px ").concat(important, ";\n  }\n  \n  .").concat(zeroRightClassName, " .").concat(zeroRightClassName, " {\n    right: 0 ").concat(important, ";\n  }\n  \n  .").concat(fullWidthClassName, " .").concat(fullWidthClassName, " {\n    margin-right: 0 ").concat(important, ";\n  }\n  \n  body[").concat(lockAttribute, "] {\n    ").concat(removedBarSizeVariable, ": ").concat(gap, "px;\n  }\n");
-};
-var getCurrentUseCounter = function() {
-	var counter = parseInt(document.body.getAttribute("data-scroll-locked") || "0", 10);
-	return isFinite(counter) ? counter : 0;
-};
-var useLockAttribute = function() {
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(function() {
-		document.body.setAttribute(lockAttribute, (getCurrentUseCounter() + 1).toString());
-		return function() {
-			var newCounter = getCurrentUseCounter() - 1;
-			if (newCounter <= 0) document.body.removeAttribute(lockAttribute);
-			else document.body.setAttribute(lockAttribute, newCounter.toString());
-		};
-	}, []);
-};
-var RemoveScrollBar = function(_a) {
-	var noRelative = _a.noRelative, noImportant = _a.noImportant, _b = _a.gapMode, gapMode = _b === void 0 ? "margin" : _b;
-	useLockAttribute();
-	var gap = react__WEBPACK_IMPORTED_MODULE_0__.useMemo(function() {
-		return getGapWidth(gapMode);
-	}, [gapMode]);
-	return react__WEBPACK_IMPORTED_MODULE_0__.createElement(Style, { styles: getStyles(gap, !noRelative, gapMode, !noImportant ? "!important" : "") });
-};
-var passiveSupported = false;
-if (typeof window !== "undefined") try {
-	var options = Object.defineProperty({}, "passive", { get: function() {
-		passiveSupported = true;
-		return true;
-	} });
-	window.addEventListener("test", options, options);
-	window.removeEventListener("test", options, options);
-} catch (err) {
-	passiveSupported = false;
-}
-var nonPassive = passiveSupported ? { passive: false } : false;
-var alwaysContainsScroll = function(node) {
-	return node.tagName === "TEXTAREA";
-};
-var elementCanBeScrolled = function(node, overflow) {
-	if (!(node instanceof Element)) return false;
-	var styles = window.getComputedStyle(node);
-	return styles[overflow] !== "hidden" && !(styles.overflowY === styles.overflowX && !alwaysContainsScroll(node) && styles[overflow] === "visible");
-};
-var elementCouldBeVScrolled = function(node) {
-	return elementCanBeScrolled(node, "overflowY");
-};
-var elementCouldBeHScrolled = function(node) {
-	return elementCanBeScrolled(node, "overflowX");
-};
-var locationCouldBeScrolled = function(axis, node) {
-	var ownerDocument = node.ownerDocument;
-	var current = node;
-	do {
-		if (typeof ShadowRoot !== "undefined" && current instanceof ShadowRoot) current = current.host;
-		if (elementCouldBeScrolled(axis, current)) {
-			var _a = getScrollVariables(axis, current);
-			if (_a[1] > _a[2]) return true;
-		}
-		current = current.parentNode;
-	} while (current && current !== ownerDocument.body);
-	return false;
-};
-var getVScrollVariables = function(_a) {
-	return [
-		_a.scrollTop,
-		_a.scrollHeight,
-		_a.clientHeight
-	];
-};
-var getHScrollVariables = function(_a) {
-	return [
-		_a.scrollLeft,
-		_a.scrollWidth,
-		_a.clientWidth
-	];
-};
-var elementCouldBeScrolled = function(axis, node) {
-	return axis === "v" ? elementCouldBeVScrolled(node) : elementCouldBeHScrolled(node);
-};
-var getScrollVariables = function(axis, node) {
-	return axis === "v" ? getVScrollVariables(node) : getHScrollVariables(node);
-};
-var getDirectionFactor = function(axis, direction) {
-	return axis === "h" && direction === "rtl" ? -1 : 1;
-};
-var handleScroll = function(axis, endTarget, event, sourceDelta, noOverscroll) {
-	var directionFactor = getDirectionFactor(axis, window.getComputedStyle(endTarget).direction);
-	var delta = directionFactor * sourceDelta;
-	var target = event.target;
-	var targetInLock = endTarget.contains(target);
-	var shouldCancelScroll = false;
-	var isDeltaPositive = delta > 0;
-	var availableScroll = 0;
-	var availableScrollTop = 0;
-	do {
-		if (!target) break;
-		var _a = getScrollVariables(axis, target), position = _a[0];
-		var elementScroll = _a[1] - _a[2] - directionFactor * position;
-		if (position || elementScroll) {
-			if (elementCouldBeScrolled(axis, target)) {
-				availableScroll += elementScroll;
-				availableScrollTop += position;
-			}
-		}
-		var parent_1 = target.parentNode;
-		target = parent_1 && parent_1.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? parent_1.host : parent_1;
-	} while (!targetInLock && target !== document.body || targetInLock && (endTarget.contains(target) || endTarget === target));
-	if (isDeltaPositive && (noOverscroll && Math.abs(availableScroll) < 1 || !noOverscroll && delta > availableScroll)) shouldCancelScroll = true;
-	else if (!isDeltaPositive && (noOverscroll && Math.abs(availableScrollTop) < 1 || !noOverscroll && -delta > availableScrollTop)) shouldCancelScroll = true;
-	return shouldCancelScroll;
-};
-var getTouchXY = function(event) {
-	return "changedTouches" in event ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [0, 0];
-};
-var getDeltaXY = function(event) {
-	return [event.deltaX, event.deltaY];
-};
-var extractRef = function(ref) {
-	return ref && "current" in ref ? ref.current : ref;
-};
-var deltaCompare = function(x, y) {
-	return x[0] === y[0] && x[1] === y[1];
-};
-var generateStyle = function(id) {
-	return "\n  .block-interactivity-".concat(id, " {pointer-events: none;}\n  .allow-interactivity-").concat(id, " {pointer-events: all;}\n");
-};
-var idCounter = 0;
-var lockStack = [];
-function RemoveScrollSideCar(props) {
-	var shouldPreventQueue = react__WEBPACK_IMPORTED_MODULE_0__.useRef([]);
-	var touchStartRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef([0, 0]);
-	var activeAxis = react__WEBPACK_IMPORTED_MODULE_0__.useRef();
-	var id = react__WEBPACK_IMPORTED_MODULE_0__.useState(idCounter++)[0];
-	var Style$1 = react__WEBPACK_IMPORTED_MODULE_0__.useState(styleSingleton)[0];
-	var lastProps = react__WEBPACK_IMPORTED_MODULE_0__.useRef(props);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(function() {
-		lastProps.current = props;
-	}, [props]);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(function() {
-		if (props.inert) {
-			document.body.classList.add("block-interactivity-".concat(id));
-			var allow_1 = __spreadArray([props.lockRef.current], (props.shards || []).map(extractRef), true).filter(Boolean);
-			allow_1.forEach(function(el) {
-				return el.classList.add("allow-interactivity-".concat(id));
-			});
-			return function() {
-				document.body.classList.remove("block-interactivity-".concat(id));
-				allow_1.forEach(function(el) {
-					return el.classList.remove("allow-interactivity-".concat(id));
-				});
-			};
-		}
-	}, [
-		props.inert,
-		props.lockRef.current,
-		props.shards
-	]);
-	var shouldCancelEvent = react__WEBPACK_IMPORTED_MODULE_0__.useCallback(function(event, parent) {
-		if ("touches" in event && event.touches.length === 2 || event.type === "wheel" && event.ctrlKey) return !lastProps.current.allowPinchZoom;
-		var touch = getTouchXY(event);
-		var touchStart = touchStartRef.current;
-		var deltaX = "deltaX" in event ? event.deltaX : touchStart[0] - touch[0];
-		var deltaY = "deltaY" in event ? event.deltaY : touchStart[1] - touch[1];
-		var currentAxis;
-		var target = event.target;
-		var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? "h" : "v";
-		if ("touches" in event && moveDirection === "h" && target.type === "range") return false;
-		var selection = window.getSelection();
-		var anchorNode = selection && selection.anchorNode;
-		if (anchorNode ? anchorNode === target || anchorNode.contains(target) : false) return false;
-		var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
-		if (!canBeScrolledInMainDirection) return true;
-		if (canBeScrolledInMainDirection) currentAxis = moveDirection;
-		else {
-			currentAxis = moveDirection === "v" ? "h" : "v";
-			canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
-		}
-		if (!canBeScrolledInMainDirection) return false;
-		if (!activeAxis.current && "changedTouches" in event && (deltaX || deltaY)) activeAxis.current = currentAxis;
-		if (!currentAxis) return true;
-		var cancelingAxis = activeAxis.current || currentAxis;
-		return handleScroll(cancelingAxis, parent, event, cancelingAxis === "h" ? deltaX : deltaY, true);
-	}, []);
-	var shouldPrevent = react__WEBPACK_IMPORTED_MODULE_0__.useCallback(function(_event) {
-		var event = _event;
-		if (!lockStack.length || lockStack[lockStack.length - 1] !== Style$1) return;
-		var delta = "deltaY" in event ? getDeltaXY(event) : getTouchXY(event);
-		var sourceEvent = shouldPreventQueue.current.filter(function(e) {
-			return e.name === event.type && (e.target === event.target || event.target === e.shadowParent) && deltaCompare(e.delta, delta);
-		})[0];
-		if (sourceEvent && sourceEvent.should) {
-			if (event.cancelable) event.preventDefault();
-			return;
-		}
-		if (!sourceEvent) {
-			var shardNodes = (lastProps.current.shards || []).map(extractRef).filter(Boolean).filter(function(node) {
-				return node.contains(event.target);
-			});
-			if (shardNodes.length > 0 ? shouldCancelEvent(event, shardNodes[0]) : !lastProps.current.noIsolation) {
-				if (event.cancelable) event.preventDefault();
-			}
-		}
-	}, []);
-	var shouldCancel = react__WEBPACK_IMPORTED_MODULE_0__.useCallback(function(name, delta, target, should) {
-		var event = {
-			name,
-			delta,
-			target,
-			should,
-			shadowParent: getOutermostShadowParent(target)
-		};
-		shouldPreventQueue.current.push(event);
-		setTimeout(function() {
-			shouldPreventQueue.current = shouldPreventQueue.current.filter(function(e) {
-				return e !== event;
-			});
-		}, 1);
-	}, []);
-	var scrollTouchStart = react__WEBPACK_IMPORTED_MODULE_0__.useCallback(function(event) {
-		touchStartRef.current = getTouchXY(event);
-		activeAxis.current = void 0;
-	}, []);
-	var scrollWheel = react__WEBPACK_IMPORTED_MODULE_0__.useCallback(function(event) {
-		shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
-	}, []);
-	var scrollTouchMove = react__WEBPACK_IMPORTED_MODULE_0__.useCallback(function(event) {
-		shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
-	}, []);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(function() {
-		lockStack.push(Style$1);
-		props.setCallbacks({
-			onScrollCapture: scrollWheel,
-			onWheelCapture: scrollWheel,
-			onTouchMoveCapture: scrollTouchMove
-		});
-		document.addEventListener("wheel", shouldPrevent, nonPassive);
-		document.addEventListener("touchmove", shouldPrevent, nonPassive);
-		document.addEventListener("touchstart", scrollTouchStart, nonPassive);
-		return function() {
-			lockStack = lockStack.filter(function(inst) {
-				return inst !== Style$1;
-			});
-			document.removeEventListener("wheel", shouldPrevent, nonPassive);
-			document.removeEventListener("touchmove", shouldPrevent, nonPassive);
-			document.removeEventListener("touchstart", scrollTouchStart, nonPassive);
-		};
-	}, []);
-	var removeScrollBar = props.removeScrollBar, inert = props.inert;
-	return react__WEBPACK_IMPORTED_MODULE_0__.createElement(react__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, inert ? react__WEBPACK_IMPORTED_MODULE_0__.createElement(Style$1, { styles: generateStyle(id) }) : null, removeScrollBar ? react__WEBPACK_IMPORTED_MODULE_0__.createElement(RemoveScrollBar, {
-		noRelative: props.noRelative,
-		gapMode: props.gapMode
-	}) : null);
-}
-function getOutermostShadowParent(node) {
-	var shadowParent = null;
-	while (node !== null) {
-		if (node instanceof ShadowRoot) {
-			shadowParent = node.host;
-			node = node.host;
-		}
-		node = node.parentNode;
-	}
-	return shadowParent;
-}
-var sidecar_default = exportSidecar(effectCar, RemoveScrollSideCar);
-var ReactRemoveScroll = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(function(props, ref) {
-	return react__WEBPACK_IMPORTED_MODULE_0__.createElement(RemoveScroll, __assign({}, props, {
-		ref,
-		sideCar: sidecar_default
-	}));
-});
-ReactRemoveScroll.classNames = RemoveScroll.classNames;
-var Combination_default = ReactRemoveScroll;
-var getDefaultParent = function(originalTarget) {
-	if (typeof document === "undefined") return null;
-	return (Array.isArray(originalTarget) ? originalTarget[0] : originalTarget).ownerDocument.body;
-};
-var counterMap = /* @__PURE__ */ new WeakMap();
-var uncontrolledNodes = /* @__PURE__ */ new WeakMap();
-var markerMap = {};
-var lockCount = 0;
-var unwrapHost = function(node) {
-	return node && (node.host || unwrapHost(node.parentNode));
-};
-var correctTargets = function(parent, targets) {
-	return targets.map(function(target) {
-		if (parent.contains(target)) return target;
-		var correctedTarget = unwrapHost(target);
-		if (correctedTarget && parent.contains(correctedTarget)) return correctedTarget;
-		console.error("aria-hidden", target, "in not contained inside", parent, ". Doing nothing");
-		return null;
-	}).filter(function(x) {
-		return Boolean(x);
-	});
-};
-var applyAttributeToOthers = function(originalTarget, parentNode, markerName, controlAttribute) {
-	var targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
-	if (!markerMap[markerName]) markerMap[markerName] = /* @__PURE__ */ new WeakMap();
-	var markerCounter = markerMap[markerName];
-	var hiddenNodes = [];
-	var elementsToKeep = /* @__PURE__ */ new Set();
-	var elementsToStop = new Set(targets);
-	var keep = function(el) {
-		if (!el || elementsToKeep.has(el)) return;
-		elementsToKeep.add(el);
-		keep(el.parentNode);
-	};
-	targets.forEach(keep);
-	var deep = function(parent) {
-		if (!parent || elementsToStop.has(parent)) return;
-		Array.prototype.forEach.call(parent.children, function(node) {
-			if (elementsToKeep.has(node)) deep(node);
-			else try {
-				var attr = node.getAttribute(controlAttribute);
-				var alreadyHidden = attr !== null && attr !== "false";
-				var counterValue = (counterMap.get(node) || 0) + 1;
-				var markerValue = (markerCounter.get(node) || 0) + 1;
-				counterMap.set(node, counterValue);
-				markerCounter.set(node, markerValue);
-				hiddenNodes.push(node);
-				if (counterValue === 1 && alreadyHidden) uncontrolledNodes.set(node, true);
-				if (markerValue === 1) node.setAttribute(markerName, "true");
-				if (!alreadyHidden) node.setAttribute(controlAttribute, "true");
-			} catch (e) {
-				console.error("aria-hidden: cannot operate on ", node, e);
-			}
-		});
-	};
-	deep(parentNode);
-	elementsToKeep.clear();
-	lockCount++;
-	return function() {
-		hiddenNodes.forEach(function(node) {
-			var counterValue = counterMap.get(node) - 1;
-			var markerValue = markerCounter.get(node) - 1;
-			counterMap.set(node, counterValue);
-			markerCounter.set(node, markerValue);
-			if (!counterValue) {
-				if (!uncontrolledNodes.has(node)) node.removeAttribute(controlAttribute);
-				uncontrolledNodes.delete(node);
-			}
-			if (!markerValue) node.removeAttribute(markerName);
-		});
-		lockCount--;
-		if (!lockCount) {
-			counterMap = /* @__PURE__ */ new WeakMap();
-			counterMap = /* @__PURE__ */ new WeakMap();
-			uncontrolledNodes = /* @__PURE__ */ new WeakMap();
-			markerMap = {};
-		}
-	};
-};
-var hideOthers = function(originalTarget, parentNode, markerName) {
-	if (markerName === void 0) markerName = "data-aria-hidden";
-	var targets = Array.from(Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
-	var activeParentNode = parentNode || getDefaultParent(originalTarget);
-	if (!activeParentNode) return function() {
-		return null;
-	};
-	targets.push.apply(targets, Array.from(activeParentNode.querySelectorAll("[aria-live], script")));
-	return applyAttributeToOthers(targets, activeParentNode, markerName, "aria-hidden");
-};
-var DIALOG_NAME = "Dialog";
-var [createDialogContext, createDialogScope] = createContextScope(DIALOG_NAME);
-var [DialogProvider, useDialogContext] = createDialogContext(DIALOG_NAME);
-var Dialog$1 = (props) => {
-	const { __scopeDialog, children, open: openProp, defaultOpen, onOpenChange, modal = true } = props;
-	const triggerRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(null);
-	const contentRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(null);
-	const [open, setOpen] = useControllableState({
-		prop: openProp,
-		defaultProp: defaultOpen ?? false,
-		onChange: onOpenChange,
-		caller: DIALOG_NAME
-	});
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DialogProvider, {
-		scope: __scopeDialog,
-		triggerRef,
-		contentRef,
-		contentId: useId(),
-		titleId: useId(),
-		descriptionId: useId(),
-		open,
-		onOpenChange: setOpen,
-		onOpenToggle: react__WEBPACK_IMPORTED_MODULE_0__.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]),
-		modal,
-		children
-	});
-};
-Dialog$1.displayName = DIALOG_NAME;
-var TRIGGER_NAME = "DialogTrigger";
-var DialogTrigger$1 = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const { __scopeDialog, ...triggerProps } = props;
-	const context = useDialogContext(TRIGGER_NAME, __scopeDialog);
-	const composedTriggerRef = useComposedRefs(forwardedRef, context.triggerRef);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Primitive.button, {
-		type: "button",
-		"aria-haspopup": "dialog",
-		"aria-expanded": context.open,
-		"aria-controls": context.contentId,
-		"data-state": getState(context.open),
-		...triggerProps,
-		ref: composedTriggerRef,
-		onClick: composeEventHandlers(props.onClick, context.onOpenToggle)
-	});
-});
-DialogTrigger$1.displayName = TRIGGER_NAME;
-var PORTAL_NAME = "DialogPortal";
-var [PortalProvider, usePortalContext] = createDialogContext(PORTAL_NAME, { forceMount: void 0 });
-var DialogPortal$1 = (props) => {
-	const { __scopeDialog, forceMount, children, container } = props;
-	const context = useDialogContext(PORTAL_NAME, __scopeDialog);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(PortalProvider, {
-		scope: __scopeDialog,
-		forceMount,
-		children: react__WEBPACK_IMPORTED_MODULE_0__.Children.map(children, (child) => /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Presence, {
-			present: forceMount || context.open,
-			children: /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Portal, {
-				asChild: true,
-				container,
-				children: child
-			})
-		}))
-	});
-};
-DialogPortal$1.displayName = PORTAL_NAME;
-var OVERLAY_NAME = "DialogOverlay";
-var DialogOverlay$1 = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const portalContext = usePortalContext(OVERLAY_NAME, props.__scopeDialog);
-	const { forceMount = portalContext.forceMount, ...overlayProps } = props;
-	const context = useDialogContext(OVERLAY_NAME, props.__scopeDialog);
-	return context.modal ? /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Presence, {
-		present: forceMount || context.open,
-		children: /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DialogOverlayImpl, {
-			...overlayProps,
-			ref: forwardedRef
-		})
-	}) : null;
-});
-DialogOverlay$1.displayName = OVERLAY_NAME;
-var Slot = /* @__PURE__ */ createSlot("DialogOverlay.RemoveScroll");
-var DialogOverlayImpl = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const { __scopeDialog, ...overlayProps } = props;
-	const context = useDialogContext(OVERLAY_NAME, __scopeDialog);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Combination_default, {
-		as: Slot,
-		allowPinchZoom: true,
-		shards: [context.contentRef],
-		children: /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Primitive.div, {
-			"data-state": getState(context.open),
-			...overlayProps,
-			ref: forwardedRef,
-			style: {
-				pointerEvents: "auto",
-				...overlayProps.style
-			}
-		})
-	});
-});
-var CONTENT_NAME = "DialogContent";
-var DialogContent$1 = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const portalContext = usePortalContext(CONTENT_NAME, props.__scopeDialog);
-	const { forceMount = portalContext.forceMount, ...contentProps } = props;
-	const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Presence, {
-		present: forceMount || context.open,
-		children: context.modal ? /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DialogContentModal, {
-			...contentProps,
-			ref: forwardedRef
-		}) : /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DialogContentNonModal, {
-			...contentProps,
-			ref: forwardedRef
-		})
-	});
-});
-DialogContent$1.displayName = CONTENT_NAME;
-var DialogContentModal = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);
-	const contentRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(null);
-	const composedRefs = useComposedRefs(forwardedRef, context.contentRef, contentRef);
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		const content = contentRef.current;
-		if (content) return hideOthers(content);
-	}, []);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DialogContentImpl, {
-		...props,
-		ref: composedRefs,
-		trapFocus: context.open,
-		disableOutsidePointerEvents: true,
-		onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event) => {
-			event.preventDefault();
-			context.triggerRef.current?.focus();
-		}),
-		onPointerDownOutside: composeEventHandlers(props.onPointerDownOutside, (event) => {
-			const originalEvent = event.detail.originalEvent;
-			const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
-			if (originalEvent.button === 2 || ctrlLeftClick) event.preventDefault();
-		}),
-		onFocusOutside: composeEventHandlers(props.onFocusOutside, (event) => event.preventDefault())
-	});
-});
-var DialogContentNonModal = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const context = useDialogContext(CONTENT_NAME, props.__scopeDialog);
-	const hasInteractedOutsideRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(false);
-	const hasPointerDownOutsideRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(false);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DialogContentImpl, {
-		...props,
-		ref: forwardedRef,
-		trapFocus: false,
-		disableOutsidePointerEvents: false,
-		onCloseAutoFocus: (event) => {
-			props.onCloseAutoFocus?.(event);
-			if (!event.defaultPrevented) {
-				if (!hasInteractedOutsideRef.current) context.triggerRef.current?.focus();
-				event.preventDefault();
-			}
-			hasInteractedOutsideRef.current = false;
-			hasPointerDownOutsideRef.current = false;
-		},
-		onInteractOutside: (event) => {
-			props.onInteractOutside?.(event);
-			if (!event.defaultPrevented) {
-				hasInteractedOutsideRef.current = true;
-				if (event.detail.originalEvent.type === "pointerdown") hasPointerDownOutsideRef.current = true;
-			}
-			const target = event.target;
-			if (context.triggerRef.current?.contains(target)) event.preventDefault();
-			if (event.detail.originalEvent.type === "focusin" && hasPointerDownOutsideRef.current) event.preventDefault();
-		}
-	});
-});
-var DialogContentImpl = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const { __scopeDialog, trapFocus, onOpenAutoFocus, onCloseAutoFocus, ...contentProps } = props;
-	const context = useDialogContext(CONTENT_NAME, __scopeDialog);
-	const contentRef = react__WEBPACK_IMPORTED_MODULE_0__.useRef(null);
-	const composedRefs = useComposedRefs(forwardedRef, contentRef);
-	useFocusGuards();
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)(react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.Fragment, { children: [/* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(FocusScope, {
-		asChild: true,
-		loop: true,
-		trapped: trapFocus,
-		onMountAutoFocus: onOpenAutoFocus,
-		onUnmountAutoFocus: onCloseAutoFocus,
-		children: /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DismissableLayer, {
-			role: "dialog",
-			id: context.contentId,
-			"aria-describedby": context.descriptionId,
-			"aria-labelledby": context.titleId,
-			"data-state": getState(context.open),
-			...contentProps,
-			ref: composedRefs,
-			onDismiss: () => context.onOpenChange(false)
-		})
-	}), /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)(react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.Fragment, { children: [/* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(TitleWarning, { titleId: context.titleId }), /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DescriptionWarning, {
-		contentRef,
-		descriptionId: context.descriptionId
-	})] })] });
-});
-var TITLE_NAME = "DialogTitle";
-var DialogTitle$1 = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const { __scopeDialog, ...titleProps } = props;
-	const context = useDialogContext(TITLE_NAME, __scopeDialog);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Primitive.h2, {
-		id: context.titleId,
-		...titleProps,
-		ref: forwardedRef
-	});
-});
-DialogTitle$1.displayName = TITLE_NAME;
-var DESCRIPTION_NAME = "DialogDescription";
-var DialogDescription$1 = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const { __scopeDialog, ...descriptionProps } = props;
-	const context = useDialogContext(DESCRIPTION_NAME, __scopeDialog);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Primitive.p, {
-		id: context.descriptionId,
-		...descriptionProps,
-		ref: forwardedRef
-	});
-});
-DialogDescription$1.displayName = DESCRIPTION_NAME;
-var CLOSE_NAME = "DialogClose";
-var DialogClose = react__WEBPACK_IMPORTED_MODULE_0__.forwardRef((props, forwardedRef) => {
-	const { __scopeDialog, ...closeProps } = props;
-	const context = useDialogContext(CLOSE_NAME, __scopeDialog);
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Primitive.button, {
-		type: "button",
-		...closeProps,
-		ref: forwardedRef,
-		onClick: composeEventHandlers(props.onClick, () => context.onOpenChange(false))
-	});
-});
-DialogClose.displayName = CLOSE_NAME;
-function getState(open) {
-	return open ? "open" : "closed";
-}
-var TITLE_WARNING_NAME = "DialogTitleWarning";
-var [WarningProvider, useWarningContext] = createContext2(TITLE_WARNING_NAME, {
-	contentName: CONTENT_NAME,
-	titleName: TITLE_NAME,
-	docsSlug: "dialog"
-});
-var TitleWarning = ({ titleId }) => {
-	const titleWarningContext = useWarningContext(TITLE_WARNING_NAME);
-	const MESSAGE = `\`${titleWarningContext.contentName}\` requires a \`${titleWarningContext.titleName}\` for the component to be accessible for screen reader users.
-
-If you want to hide the \`${titleWarningContext.titleName}\`, you can wrap it with our VisuallyHidden component.
-
-For more information, see https://radix-ui.com/primitives/docs/components/${titleWarningContext.docsSlug}`;
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		if (titleId) {
-			if (!document.getElementById(titleId)) console.error(MESSAGE);
-		}
-	}, [MESSAGE, titleId]);
-	return null;
-};
-var DESCRIPTION_WARNING_NAME = "DialogDescriptionWarning";
-var DescriptionWarning = ({ contentRef, descriptionId }) => {
-	const MESSAGE = `Warning: Missing \`Description\` or \`aria-describedby={undefined}\` for {${useWarningContext(DESCRIPTION_WARNING_NAME).contentName}}.`;
-	react__WEBPACK_IMPORTED_MODULE_0__.useEffect(() => {
-		const describedById = contentRef.current?.getAttribute("aria-describedby");
-		if (descriptionId && describedById) {
-			if (!document.getElementById(descriptionId)) console.warn(MESSAGE);
-		}
-	}, [
-		MESSAGE,
-		contentRef,
-		descriptionId
-	]);
-	return null;
-};
-var Root = Dialog$1;
-var Trigger = DialogTrigger$1;
-var Portal$1 = DialogPortal$1;
-var Overlay = DialogOverlay$1;
-var Content = DialogContent$1;
-var Title = DialogTitle$1;
-var Description = DialogDescription$1;
-var Close = DialogClose;
-/**
-* @license lucide-react v0.475.0 - ISC
-*
-* This source code is licensed under the ISC license.
-* See the LICENSE file in the root directory of this source tree.
-*/
-var toKebabCase = (string) => string.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-var mergeClasses = (...classes) => classes.filter((className, index, array) => {
-	return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index;
-}).join(" ").trim();
-/**
-* @license lucide-react v0.475.0 - ISC
-*
-* This source code is licensed under the ISC license.
-* See the LICENSE file in the root directory of this source tree.
-*/
-var defaultAttributes = {
-	xmlns: "http://www.w3.org/2000/svg",
-	width: 24,
-	height: 24,
-	viewBox: "0 0 24 24",
-	fill: "none",
-	stroke: "currentColor",
-	strokeWidth: 2,
-	strokeLinecap: "round",
-	strokeLinejoin: "round"
-};
-/**
-* @license lucide-react v0.475.0 - ISC
-*
-* This source code is licensed under the ISC license.
-* See the LICENSE file in the root directory of this source tree.
-*/
-var Icon = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ color = "currentColor", size = 24, strokeWidth = 2, absoluteStrokeWidth, className = "", children, iconNode, ...rest }, ref) => {
-	return (0,react__WEBPACK_IMPORTED_MODULE_0__.createElement)("svg", {
-		ref,
-		...defaultAttributes,
-		width: size,
-		height: size,
-		stroke: color,
-		strokeWidth: absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth,
-		className: mergeClasses("lucide", className),
-		...rest
-	}, [...iconNode.map(([tag, attrs]) => (0,react__WEBPACK_IMPORTED_MODULE_0__.createElement)(tag, attrs)), ...Array.isArray(children) ? children : [children]]);
-});
-/**
-* @license lucide-react v0.475.0 - ISC
-*
-* This source code is licensed under the ISC license.
-* See the LICENSE file in the root directory of this source tree.
-*/
-var createLucideIcon = (iconName, iconNode) => {
-	const Component = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ className, ...props }, ref) => (0,react__WEBPACK_IMPORTED_MODULE_0__.createElement)(Icon, {
-		ref,
-		iconNode,
-		className: mergeClasses(`lucide-${toKebabCase(iconName)}`, className),
-		...props
-	}));
-	Component.displayName = `${iconName}`;
-	return Component;
-};
-var X = createLucideIcon("X", [["path", {
-	d: "M18 6 6 18",
-	key: "1bl5f8"
-}], ["path", {
-	d: "m6 6 12 12",
-	key: "d8bk6v"
-}]]);
-function Dialog({ ...props }) {
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Root, {
-		"data-slot": "dialog",
-		...props
-	});
-}
-function DialogTrigger({ ...props }) {
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Trigger, {
-		"data-slot": "dialog-trigger",
-		...props
-	});
-}
-function DialogPortal({ ...props }) {
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Portal$1, {
-		"data-slot": "dialog-portal",
-		...props
-	});
-}
-function DialogOverlay({ className, ...props }) {
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Overlay, {
-		"data-slot": "dialog-overlay",
-		className: cn("data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50", className),
-		...props
-	});
-}
-function DialogContent({ className, children, showCloseButton = true, ...props }) {
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)(DialogPortal, {
-		"data-slot": "dialog-portal",
-		children: [/* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DialogOverlay, {}), /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)(Content, {
-			"data-slot": "dialog-content",
-			className: cn("bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 outline-none sm:max-w-lg", className),
-			...props,
-			children: [children, showCloseButton && /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)(Close, {
-				"data-slot": "dialog-close",
-				className: "ring-offset-background focus:ring-ring data-[state=open]:bg-accent data-[state=open]:text-muted-foreground absolute top-4 right-4 rounded-xs opacity-70 transition-opacity hover:opacity-100 focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-				children: [/* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(X, {}), /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("span", {
-					className: "sr-only",
-					children: "Close"
-				})]
-			})]
-		})]
-	});
-}
-function DialogHeader({ className, ...props }) {
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("div", {
-		"data-slot": "dialog-header",
-		className: cn("flex flex-col gap-2 text-center sm:text-left", className),
-		...props
-	});
-}
-function DialogTitle({ className, ...props }) {
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Title, {
-		"data-slot": "dialog-title",
-		className: cn("text-lg leading-none font-semibold", className),
-		...props
-	});
-}
-function DialogDescription({ className, ...props }) {
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Description, {
-		"data-slot": "dialog-description",
-		className: cn("text-muted-foreground text-sm", className),
-		...props
-	});
-}
-function App() {
-	return /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(ThemeProvider, {
-		defaultTheme: "dark",
-		storageKey: "iconoma-studio-theme",
-		children: /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)("div", {
-			className: "flex flex-col items-center justify-center gap-4",
-			children: [/* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)("h1", {
-				className: "text-2xl font-bold",
-				children: "Iconoma Studio"
-			}), /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)(Dialog, { children: [/* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DialogTrigger, {
-				asChild: true,
-				children: /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(Button, {
-					size: "sm",
-					children: "Open Dialog"
-				})
-			}), /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DialogContent, { children: /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsxs)(DialogHeader, { children: [/* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DialogTitle, { children: "Dialog Title" }), /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(DialogDescription, { children: "Dialog Description" })] }) })] })]
-		})
-	});
-}
-function render(_url) {
-	return { html: (0,react_dom_server__WEBPACK_IMPORTED_MODULE_1__/* .renderToString */ .F0)(/* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(react__WEBPACK_IMPORTED_MODULE_0__.StrictMode, { children: /* @__PURE__ */ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__.jsx)(App, {}) })) };
-}
-
-
-
-/***/ })
-
-};