@nation-a/ui 0.2.1 → 0.4.0

package/dist/index.cjs

@@ -0,0 +1,4356 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const React = require("react");
+const reactDom = require("react-dom");
+function isObject$1(value) {
+  return typeof value === "object" && value != null && !Array.isArray(value);
+}
+var isObjectOrArray = (obj) => typeof obj === "object" && obj !== null;
+function compact$1(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([_, value2]) => value2 !== void 0));
+}
+var isBaseCondition = (v2) => v2 === "base";
+function filterBaseConditions(c) {
+  return c.slice().filter((v2) => !isBaseCondition(v2));
+}
+function toChar(code) {
+  return String.fromCharCode(code + (code > 25 ? 39 : 97));
+}
+function toName(code) {
+  let name = "";
+  let x;
+  for (x = Math.abs(code); x > 52; x = x / 52 | 0)
+    name = toChar(x % 52) + name;
+  return toChar(x % 52) + name;
+}
+function toPhash(h, x) {
+  let i = x.length;
+  while (i)
+    h = h * 33 ^ x.charCodeAt(--i);
+  return h;
+}
+function toHash(value) {
+  return toName(toPhash(5381, value) >>> 0);
+}
+var importantRegex = /\s*!(important)?/i;
+function isImportant(value) {
+  return typeof value === "string" ? importantRegex.test(value) : false;
+}
+function withoutImportant(value) {
+  return typeof value === "string" ? value.replace(importantRegex, "").trim() : value;
+}
+function withoutSpace(str) {
+  return typeof str === "string" ? str.replaceAll(" ", "_") : str;
+}
+var memo = (fn) => {
+  const cache = /* @__PURE__ */ new Map();
+  const get = (...args) => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  };
+  return get;
+};
+function mergeProps$1(...sources) {
+  return sources.reduce((prev, obj) => {
+    if (!obj)
+      return prev;
+    Object.keys(obj).forEach((key) => {
+      const prevValue = prev[key];
+      const value = obj[key];
+      if (isObject$1(prevValue) && isObject$1(value)) {
+        prev[key] = mergeProps$1(prevValue, value);
+      } else {
+        prev[key] = value;
+      }
+    });
+    return prev;
+  }, {});
+}
+var isNotNullish = (element) => element != null;
+function walkObject(target, predicate, options = {}) {
+  const { stop, getKey } = options;
+  function inner(value, path = []) {
+    if (isObjectOrArray(value)) {
+      const result = {};
+      for (const [prop, child] of Object.entries(value)) {
+        const key = (getKey == null ? void 0 : getKey(prop, child)) ?? prop;
+        const childPath = [...path, key];
+        if (stop == null ? void 0 : stop(value, childPath)) {
+          return predicate(value, path);
+        }
+        const next = inner(child, childPath);
+        if (isNotNullish(next)) {
+          result[key] = next;
+        }
+      }
+      return result;
+    }
+    return predicate(value, path);
+  }
+  return inner(target);
+}
+function mapObject(obj, fn) {
+  if (Array.isArray(obj))
+    return obj.map((value) => fn(value));
+  if (!isObject$1(obj))
+    return fn(obj);
+  return walkObject(obj, (value) => fn(value));
+}
+function toResponsiveObject(values, breakpoints2) {
+  return values.reduce(
+    (acc, current, index) => {
+      const key = breakpoints2[index];
+      if (current != null) {
+        acc[key] = current;
+      }
+      return acc;
+    },
+    {}
+  );
+}
+function normalizeStyleObject(styles, context2, shorthand = true) {
+  const { utility, conditions: conditions2 } = context2;
+  const { hasShorthand, resolveShorthand: resolveShorthand2 } = utility;
+  return walkObject(
+    styles,
+    (value) => {
+      return Array.isArray(value) ? toResponsiveObject(value, conditions2.breakpoints.keys) : value;
+    },
+    {
+      stop: (value) => Array.isArray(value),
+      getKey: shorthand ? (prop) => hasShorthand ? resolveShorthand2(prop) : prop : void 0
+    }
+  );
+}
+var fallbackCondition = {
+  shift: (v2) => v2,
+  finalize: (v2) => v2,
+  breakpoints: { keys: [] }
+};
+var sanitize = (value) => typeof value === "string" ? value.replaceAll(/[\n\s]+/g, " ") : value;
+function createCss(context2) {
+  const { utility, hash, conditions: conds = fallbackCondition } = context2;
+  const formatClassName = (str) => [utility.prefix, str].filter(Boolean).join("-");
+  const hashFn = (conditions2, className) => {
+    let result;
+    if (hash) {
+      const baseArray = [...conds.finalize(conditions2), className];
+      result = formatClassName(utility.toHash(baseArray, toHash));
+    } else {
+      const baseArray = [...conds.finalize(conditions2), formatClassName(className)];
+      result = baseArray.join(":");
+    }
+    return result;
+  };
+  return memo(({ base, ...styles } = {}) => {
+    const styleObject = Object.assign(styles, base);
+    const normalizedObject = normalizeStyleObject(styleObject, context2);
+    const classNames = /* @__PURE__ */ new Set();
+    walkObject(normalizedObject, (value, paths) => {
+      if (value == null)
+        return;
+      const important = isImportant(value);
+      const [prop, ...allConditions] = conds.shift(paths);
+      const conditions2 = filterBaseConditions(allConditions);
+      const transformed = utility.transform(prop, withoutImportant(sanitize(value)));
+      let className = hashFn(conditions2, transformed.className);
+      if (important)
+        className = `${className}!`;
+      classNames.add(className);
+    });
+    return Array.from(classNames).join(" ");
+  });
+}
+function compactStyles(...styles) {
+  return styles.flat().filter((style) => isObject$1(style) && Object.keys(compact$1(style)).length > 0);
+}
+function createMergeCss(context2) {
+  function resolve(styles) {
+    const allStyles = compactStyles(...styles);
+    if (allStyles.length === 1)
+      return allStyles;
+    return allStyles.map((style) => normalizeStyleObject(style, context2));
+  }
+  function mergeCss2(...styles) {
+    return mergeProps$1(...resolve(styles));
+  }
+  function assignCss(...styles) {
+    return Object.assign({}, ...resolve(styles));
+  }
+  return { mergeCss: memo(mergeCss2), assignCss };
+}
+var wordRegex = /([A-Z])/g;
+var msRegex = /^ms-/;
+var hypenateProperty = memo((property) => {
+  if (property.startsWith("--"))
+    return property;
+  return property.replace(wordRegex, "-$1").replace(msRegex, "-ms-").toLowerCase();
+});
+var fns = ["min", "max", "clamp", "calc"];
+var fnRegExp = new RegExp(`^(${fns.join("|")})\\(.*\\)`);
+var isCssFunction = (v2) => typeof v2 === "string" && fnRegExp.test(v2);
+var lengthUnits = "cm,mm,Q,in,pc,pt,px,em,ex,ch,rem,lh,rlh,vw,vh,vmin,vmax,vb,vi,svw,svh,lvw,lvh,dvw,dvh,cqw,cqh,cqi,cqb,cqmin,cqmax,%";
+var lengthUnitsPattern = `(?:${lengthUnits.split(",").join("|")})`;
+var lengthRegExp = new RegExp(`^[+-]?[0-9]*.?[0-9]+(?:[eE][+-]?[0-9]+)?${lengthUnitsPattern}$`);
+var isCssUnit = (v2) => typeof v2 === "string" && lengthRegExp.test(v2);
+var isCssVar = (v2) => typeof v2 === "string" && /^var\(--.+\)$/.test(v2);
+var patternFns = {
+  map: mapObject,
+  isCssFunction,
+  isCssVar,
+  isCssUnit
+};
+var getPatternStyles = (pattern, styles) => {
+  if (!(pattern == null ? void 0 : pattern.defaultValues))
+    return styles;
+  const defaults2 = typeof pattern.defaultValues === "function" ? pattern.defaultValues(styles) : pattern.defaultValues;
+  return Object.assign({}, defaults2, compact$1(styles));
+};
+var getSlotRecipes = (recipe = {}) => {
+  const init = (slot) => {
+    var _a;
+    return {
+      className: [recipe.className, slot].filter(Boolean).join("__"),
+      base: ((_a = recipe.base) == null ? void 0 : _a[slot]) ?? {},
+      variants: {},
+      defaultVariants: recipe.defaultVariants ?? {},
+      compoundVariants: recipe.compoundVariants ? getSlotCompoundVariant(recipe.compoundVariants, slot) : []
+    };
+  };
+  const slots = recipe.slots ?? [];
+  const recipeParts = slots.map((slot) => [slot, init(slot)]);
+  for (const [variantsKey, variantsSpec] of Object.entries(recipe.variants ?? {})) {
+    for (const [variantKey, variantSpec] of Object.entries(variantsSpec)) {
+      recipeParts.forEach(([slot, slotRecipe]) => {
+        var _a;
+        (_a = slotRecipe.variants)[variantsKey] ?? (_a[variantsKey] = {});
+        slotRecipe.variants[variantsKey][variantKey] = variantSpec[slot] ?? {};
+      });
+    }
+  }
+  return Object.fromEntries(recipeParts);
+};
+var getSlotCompoundVariant = (compoundVariants, slotName) => compoundVariants.filter((compoundVariant) => compoundVariant.css[slotName]).map((compoundVariant) => ({ ...compoundVariant, css: compoundVariant.css[slotName] }));
+function splitProps(props, ...keys) {
+  const descriptors = Object.getOwnPropertyDescriptors(props);
+  const dKeys = Object.keys(descriptors);
+  const split = (k) => {
+    const clone = {};
+    for (let i = 0; i < k.length; i++) {
+      const key = k[i];
+      if (descriptors[key]) {
+        Object.defineProperty(clone, key, descriptors[key]);
+        delete descriptors[key];
+      }
+    }
+    return clone;
+  };
+  const fn = (key) => split(Array.isArray(key) ? key : dKeys.filter(key));
+  return keys.map(fn).concat(split(dKeys));
+}
+var uniq = (...items) => {
+  const set2 = items.reduce((acc, currItems) => {
+    if (currItems) {
+      currItems.forEach((item) => acc.add(item));
+    }
+    return acc;
+  }, /* @__PURE__ */ new Set([]));
+  return Array.from(set2);
+};
+var htmlProps = ["htmlSize", "htmlTranslate", "htmlWidth", "htmlHeight"];
+function convert(key) {
+  return htmlProps.includes(key) ? key.replace("html", "").toLowerCase() : key;
+}
+function normalizeHTMLProps(props) {
+  return Object.fromEntries(Object.entries(props).map(([key, value]) => [convert(key), value]));
+}
+normalizeHTMLProps.keys = htmlProps;
+const conditionsStr = "_hover,_focus,_focusWithin,_focusVisible,_disabled,_active,_visited,_target,_readOnly,_readWrite,_empty,_checked,_enabled,_expanded,_highlighted,_complete,_incomplete,_dragging,_before,_after,_firstLetter,_firstLine,_marker,_selection,_file,_backdrop,_first,_last,_only,_even,_odd,_firstOfType,_lastOfType,_onlyOfType,_peerFocus,_peerHover,_peerActive,_peerFocusWithin,_peerFocusVisible,_peerDisabled,_peerChecked,_peerInvalid,_peerExpanded,_peerPlaceholderShown,_groupFocus,_groupHover,_groupActive,_groupFocusWithin,_groupFocusVisible,_groupDisabled,_groupChecked,_groupExpanded,_groupInvalid,_indeterminate,_required,_valid,_invalid,_autofill,_inRange,_outOfRange,_placeholder,_placeholderShown,_pressed,_selected,_grabbed,_underValue,_overValue,_atValue,_default,_optional,_open,_closed,_fullscreen,_loading,_hidden,_current,_currentPage,_currentStep,_today,_unavailable,_rangeStart,_rangeEnd,_now,_topmost,_motionReduce,_motionSafe,_print,_landscape,_portrait,_dark,_light,_osDark,_osLight,_highContrast,_lessContrast,_moreContrast,_ltr,_rtl,_scrollbar,_scrollbarThumb,_scrollbarTrack,_horizontal,_vertical,_icon,_starting,_collapsed,_off,_on,sm,smOnly,smDown,md,mdOnly,mdDown,lg,lgOnly,lgDown,xl,xlOnly,xlDown,2xl,2xlOnly,2xlDown,smToMd,smToLg,smToXl,smTo2xl,mdToLg,mdToXl,mdTo2xl,lgToXl,lgTo2xl,xlTo2xl,base";
+const conditions$1 = new Set(conditionsStr.split(","));
+const conditionRegex = /^@|&|&$/;
+function isCondition(value) {
+  return conditions$1.has(value) || conditionRegex.test(value);
+}
+const underscoreRegex = /^_/;
+const conditionsSelectorRegex = /&|@/;
+function finalizeConditions(paths) {
+  return paths.map((path) => {
+    if (conditions$1.has(path)) {
+      return path.replace(underscoreRegex, "");
+    }
+    if (conditionsSelectorRegex.test(path)) {
+      return `[${withoutSpace(path.trim())}]`;
+    }
+    return path;
+  });
+}
+function sortConditions(paths) {
+  return paths.sort((a, b) => {
+    const aa = isCondition(a);
+    const bb = isCondition(b);
+    if (aa && !bb) return 1;
+    if (!aa && bb) return -1;
+    return 0;
+  });
+}
+const utilities = "aspectRatio:asp,boxDecorationBreak:bx-db,zIndex:z,boxSizing:bx-s,objectPosition:obj-p,objectFit:obj-f,overscrollBehavior:ovs-b,overscrollBehaviorX:ovs-bx,overscrollBehaviorY:ovs-by,position:pos/1,top:top,left:left,inset:inset,insetInline:inset-x/insetX,insetBlock:inset-y/insetY,insetBlockEnd:inset-be,insetBlockStart:inset-bs,insetInlineEnd:inset-e/insetEnd/end,insetInlineStart:inset-s/insetStart/start,right:right,bottom:bottom,float:float,visibility:vis,display:d,hideFrom:hide,hideBelow:show,flexBasis:flex-b,flex:flex,flexDirection:flex-d/flexDir,flexGrow:flex-g,flexShrink:flex-sh,gridTemplateColumns:grid-tc,gridTemplateRows:grid-tr,gridColumn:grid-c,gridRow:grid-r,gridColumnStart:grid-cs,gridColumnEnd:grid-ce,gridAutoFlow:grid-af,gridAutoColumns:grid-ac,gridAutoRows:grid-ar,gap:gap,gridGap:grid-g,gridRowGap:grid-rg,gridColumnGap:grid-cg,rowGap:rg,columnGap:cg,justifyContent:jc,alignContent:ac,alignItems:ai,alignSelf:as,padding:p/1,paddingLeft:pl/1,paddingRight:pr/1,paddingTop:pt/1,paddingBottom:pb/1,paddingBlock:py/1/paddingY,paddingBlockEnd:pbe,paddingBlockStart:pbs,paddingInline:px/paddingX/1,paddingInlineEnd:pe/1/paddingEnd,paddingInlineStart:ps/1/paddingStart,marginLeft:ml/1,marginRight:mr/1,marginTop:mt/1,marginBottom:mb/1,margin:m/1,marginBlock:my/1/marginY,marginBlockEnd:mbe,marginBlockStart:mbs,marginInline:mx/1/marginX,marginInlineEnd:me/1/marginEnd,marginInlineStart:ms/1/marginStart,spaceX:sx,spaceY:sy,outlineWidth:ring-w/ringWidth,outlineColor:ring-c/ringColor,outline:ring/1,outlineOffset:ring-o/ringOffset,divideX:dvd-x,divideY:dvd-y,divideColor:dvd-c,divideStyle:dvd-s,width:w/1,inlineSize:w-is,minWidth:min-w/minW,minInlineSize:min-w-is,maxWidth:max-w/maxW,maxInlineSize:max-w-is,height:h/1,blockSize:h-bs,minHeight:min-h/minH,minBlockSize:min-h-bs,maxHeight:max-h/maxH,maxBlockSize:max-b,color:c,fontFamily:ff,fontSize:fs,fontSizeAdjust:fs-a,fontPalette:fp,fontKerning:fk,fontFeatureSettings:ff-s,fontWeight:fw,fontSmoothing:fsmt,fontVariant:fv,fontVariantAlternates:fv-alt,fontVariantCaps:fv-caps,fontVariationSettings:fv-s,fontVariantNumeric:fv-num,letterSpacing:ls,lineHeight:lh,textAlign:ta,textDecoration:td,textDecorationColor:td-c,textEmphasisColor:te-c,textDecorationStyle:td-s,textDecorationThickness:td-t,textUnderlineOffset:tu-o,textTransform:tt,textIndent:ti,textShadow:tsh,textShadowColor:tsh-c/textShadowColor,textOverflow:tov,verticalAlign:va,wordBreak:wb,textWrap:tw,truncate:trunc,lineClamp:lc,listStyleType:li-t,listStylePosition:li-pos,listStyleImage:li-img,listStyle:li-s,backgroundPosition:bg-p/bgPosition,backgroundPositionX:bg-p-x/bgPositionX,backgroundPositionY:bg-p-y/bgPositionY,backgroundAttachment:bg-a/bgAttachment,backgroundClip:bg-cp/bgClip,background:bg/1,backgroundColor:bg-c/bgColor,backgroundOrigin:bg-o/bgOrigin,backgroundImage:bg-i/bgImage,backgroundRepeat:bg-r/bgRepeat,backgroundBlendMode:bg-bm/bgBlendMode,backgroundSize:bg-s/bgSize,backgroundGradient:bg-grad/bgGradient,textGradient:txt-grad,gradientFromPosition:grad-from-pos,gradientToPosition:grad-to-pos,gradientFrom:grad-from,gradientTo:grad-to,gradientVia:grad-via,gradientViaPosition:grad-via-pos,borderRadius:bdr/rounded,borderTopLeftRadius:bdr-tl/roundedTopLeft,borderTopRightRadius:bdr-tr/roundedTopRight,borderBottomRightRadius:bdr-br/roundedBottomRight,borderBottomLeftRadius:bdr-bl/roundedBottomLeft,borderTopRadius:bdr-t/roundedTop,borderRightRadius:bdr-r/roundedRight,borderBottomRadius:bdr-b/roundedBottom,borderLeftRadius:bdr-l/roundedLeft,borderStartStartRadius:bdr-ss/roundedStartStart,borderStartEndRadius:bdr-se/roundedStartEnd,borderStartRadius:bdr-s/roundedStart,borderEndStartRadius:bdr-es/roundedEndStart,borderEndEndRadius:bdr-ee/roundedEndEnd,borderEndRadius:bdr-e/roundedEnd,border:bd,borderWidth:bd-w,borderTopWidth:bd-t-w,borderLeftWidth:bd-l-w,borderRightWidth:bd-r-w,borderBottomWidth:bd-b-w,borderColor:bd-c,borderInline:bd-x/borderX,borderInlineWidth:bd-x-w/borderXWidth,borderInlineColor:bd-x-c/borderXColor,borderBlock:bd-y/borderY,borderBlockWidth:bd-y-w/borderYWidth,borderBlockColor:bd-y-c/borderYColor,borderLeft:bd-l,borderLeftColor:bd-l-c,borderInlineStart:bd-s/borderStart,borderInlineStartWidth:bd-s-w/borderStartWidth,borderInlineStartColor:bd-s-c/borderStartColor,borderRight:bd-r,borderRightColor:bd-r-c,borderInlineEnd:bd-e/borderEnd,borderInlineEndWidth:bd-e-w/borderEndWidth,borderInlineEndColor:bd-e-c/borderEndColor,borderTop:bd-t,borderTopColor:bd-t-c,borderBottom:bd-b,borderBottomColor:bd-b-c,borderBlockEnd:bd-be,borderBlockEndColor:bd-be-c,borderBlockStart:bd-bs,borderBlockStartColor:bd-bs-c,opacity:op,boxShadow:bx-sh/shadow,boxShadowColor:bx-sh-c/shadowColor,mixBlendMode:mix-bm,filter:filter,brightness:brightness,contrast:contrast,grayscale:grayscale,hueRotate:hue-rotate,invert:invert,saturate:saturate,sepia:sepia,dropShadow:drop-shadow,blur:blur,backdropFilter:bkdp,backdropBlur:bkdp-blur,backdropBrightness:bkdp-brightness,backdropContrast:bkdp-contrast,backdropGrayscale:bkdp-grayscale,backdropHueRotate:bkdp-hue-rotate,backdropInvert:bkdp-invert,backdropOpacity:bkdp-opacity,backdropSaturate:bkdp-saturate,backdropSepia:bkdp-sepia,borderCollapse:bd-cl,borderSpacing:bd-sp,borderSpacingX:bd-sx,borderSpacingY:bd-sy,tableLayout:tbl,transitionTimingFunction:trs-tmf,transitionDelay:trs-dly,transitionDuration:trs-dur,transitionProperty:trs-prop,transition:trs,animation:anim,animationName:anim-n,animationTimingFunction:anim-tmf,animationDuration:anim-dur,animationDelay:anim-dly,animationPlayState:anim-ps,animationComposition:anim-comp,animationFillMode:anim-fm,animationDirection:anim-dir,animationIterationCount:anim-ic,animationRange:anim-r,animationState:anim-s,animationRangeStart:anim-rs,animationRangeEnd:anim-re,animationTimeline:anim-tl,transformOrigin:trf-o,transformBox:trf-b,transformStyle:trf-s,transform:trf,rotate:rotate,rotateX:rotate-x,rotateY:rotate-y,rotateZ:rotate-z,scale:scale,scaleX:scale-x,scaleY:scale-y,translate:translate,translateX:translate-x/x,translateY:translate-y/y,translateZ:translate-z/z,accentColor:ac-c,caretColor:ca-c,scrollBehavior:scr-bhv,scrollbar:scr-bar,scrollbarColor:scr-bar-c,scrollbarGutter:scr-bar-g,scrollbarWidth:scr-bar-w,scrollMargin:scr-m,scrollMarginLeft:scr-ml,scrollMarginRight:scr-mr,scrollMarginTop:scr-mt,scrollMarginBottom:scr-mb,scrollMarginBlock:scr-my/scrollMarginY,scrollMarginBlockEnd:scr-mbe,scrollMarginBlockStart:scr-mbt,scrollMarginInline:scr-mx/scrollMarginX,scrollMarginInlineEnd:scr-me,scrollMarginInlineStart:scr-ms,scrollPadding:scr-p,scrollPaddingBlock:scr-py/scrollPaddingY,scrollPaddingBlockStart:scr-pbs,scrollPaddingBlockEnd:scr-pbe,scrollPaddingInline:scr-px/scrollPaddingX,scrollPaddingInlineEnd:scr-pe,scrollPaddingInlineStart:scr-ps,scrollPaddingLeft:scr-pl,scrollPaddingRight:scr-pr,scrollPaddingTop:scr-pt,scrollPaddingBottom:scr-pb,scrollSnapAlign:scr-sa,scrollSnapStop:scrs-s,scrollSnapType:scrs-t,scrollSnapStrictness:scrs-strt,scrollSnapMargin:scrs-m,scrollSnapMarginTop:scrs-mt,scrollSnapMarginBottom:scrs-mb,scrollSnapMarginLeft:scrs-ml,scrollSnapMarginRight:scrs-mr,scrollSnapCoordinate:scrs-c,scrollSnapDestination:scrs-d,scrollSnapPointsX:scrs-px,scrollSnapPointsY:scrs-py,scrollSnapTypeX:scrs-tx,scrollSnapTypeY:scrs-ty,scrollTimeline:scrtl,scrollTimelineAxis:scrtl-a,scrollTimelineName:scrtl-n,touchAction:tch-a,userSelect:us,overflow:ov,overflowWrap:ov-wrap,overflowX:ov-x,overflowY:ov-y,overflowAnchor:ov-a,overflowBlock:ov-b,overflowInline:ov-i,overflowClipBox:ovcp-bx,overflowClipMargin:ovcp-m,overscrollBehaviorBlock:ovs-bb,overscrollBehaviorInline:ovs-bi,fill:fill,stroke:stk,strokeWidth:stk-w,strokeDasharray:stk-dsh,strokeDashoffset:stk-do,strokeLinecap:stk-lc,strokeLinejoin:stk-lj,strokeMiterlimit:stk-ml,strokeOpacity:stk-op,srOnly:sr,debug:debug,appearance:ap,backfaceVisibility:bfv,clipPath:cp-path,hyphens:hy,mask:msk,maskImage:msk-i,maskSize:msk-s,textSizeAdjust:txt-adj,container:cq,containerName:cq-n,containerType:cq-t,textStyle:textStyle";
+const classNameByProp = /* @__PURE__ */ new Map();
+const shorthands = /* @__PURE__ */ new Map();
+utilities.split(",").forEach((utility) => {
+  const [prop, meta] = utility.split(":");
+  const [className, ...shorthandList] = meta.split("/");
+  classNameByProp.set(prop, className);
+  if (shorthandList.length) {
+    shorthandList.forEach((shorthand) => {
+      shorthands.set(shorthand === "1" ? className : shorthand, prop);
+    });
+  }
+});
+const resolveShorthand = (prop) => shorthands.get(prop) || prop;
+const context = {
+  conditions: {
+    shift: sortConditions,
+    finalize: finalizeConditions,
+    breakpoints: { keys: ["base", "sm", "md", "lg", "xl", "2xl"] }
+  },
+  utility: {
+    transform: (prop, value) => {
+      const key = resolveShorthand(prop);
+      const propKey = classNameByProp.get(key) || hypenateProperty(key);
+      return { className: `${propKey}_${withoutSpace(value)}` };
+    },
+    hasShorthand: true,
+    toHash: (path, hashFn) => hashFn(path.join(":")),
+    resolveShorthand
+  }
+};
+const cssFn = createCss(context);
+const css$1 = (...styles) => cssFn(mergeCss(...styles));
+css$1.raw = (...styles) => mergeCss(...styles);
+const { mergeCss } = createMergeCss(context);
+function cx() {
+  let str = "", i = 0, arg;
+  for (; i < arguments.length; ) {
+    if ((arg = arguments[i++]) && typeof arg === "string") {
+      str && (str += " ");
+      str += arg;
+    }
+  }
+  return str;
+}
+const defaults = (conf) => ({
+  base: {},
+  variants: {},
+  defaultVariants: {},
+  compoundVariants: [],
+  ...conf
+});
+function cva(config) {
+  const { base, variants, defaultVariants, compoundVariants } = defaults(config);
+  const getVariantProps = (variants2) => ({ ...defaultVariants, ...compact$1(variants2) });
+  function resolve(props = {}) {
+    var _a;
+    const computedVariants = getVariantProps(props);
+    let variantCss = { ...base };
+    for (const [key, value] of Object.entries(computedVariants)) {
+      if ((_a = variants[key]) == null ? void 0 : _a[value]) {
+        variantCss = mergeCss(variantCss, variants[key][value]);
+      }
+    }
+    const compoundVariantCss = getCompoundVariantCss(compoundVariants, computedVariants);
+    return mergeCss(variantCss, compoundVariantCss);
+  }
+  function merge(__cva) {
+    const override = defaults(__cva.config);
+    const variantKeys2 = uniq(__cva.variantKeys, Object.keys(variants));
+    return cva({
+      base: mergeCss(base, override.base),
+      variants: Object.fromEntries(
+        variantKeys2.map((key) => [key, mergeCss(variants[key], override.variants[key])])
+      ),
+      defaultVariants: mergeProps$1(defaultVariants, override.defaultVariants),
+      compoundVariants: [...compoundVariants, ...override.compoundVariants]
+    });
+  }
+  function cvaFn(props) {
+    return css$1(resolve(props));
+  }
+  const variantKeys = Object.keys(variants);
+  function splitVariantProps(props) {
+    return splitProps(props, variantKeys);
+  }
+  const variantMap = Object.fromEntries(Object.entries(variants).map(([key, value]) => [key, Object.keys(value)]));
+  return Object.assign(memo(cvaFn), {
+    __cva__: true,
+    variantMap,
+    variantKeys,
+    raw: resolve,
+    config,
+    merge,
+    splitVariantProps,
+    getVariantProps
+  });
+}
+function getCompoundVariantCss(compoundVariants, variantMap) {
+  let result = {};
+  compoundVariants.forEach((compoundVariant) => {
+    const isMatching = Object.entries(compoundVariant).every(([key, value]) => {
+      if (key === "css") return true;
+      const values = Array.isArray(value) ? value : [value];
+      return values.some((value2) => variantMap[key] === value2);
+    });
+    if (isMatching) {
+      result = mergeCss(result, compoundVariant.css);
+    }
+  });
+  return result;
+}
+const slotClass = (className, slot) => className + "__" + slot;
+function sva(config) {
+  const slots = Object.entries(getSlotRecipes(config)).map(([slot, slotCva]) => [slot, cva(slotCva)]);
+  const defaultVariants = config.defaultVariants ?? {};
+  function svaFn(props) {
+    const result = slots.map(([slot, cvaFn]) => [slot, cx(cvaFn(props), config.className && slotClass(config.className, slot))]);
+    return Object.fromEntries(result);
+  }
+  function raw(props) {
+    const result = slots.map(([slot, cvaFn]) => [slot, cvaFn.raw(props)]);
+    return Object.fromEntries(result);
+  }
+  const variants = config.variants ?? {};
+  const variantKeys = Object.keys(variants);
+  function splitVariantProps(props) {
+    return splitProps(props, variantKeys);
+  }
+  const getVariantProps = (variants2) => ({ ...defaultVariants || {}, ...compact$1(variants2) });
+  const variantMap = Object.fromEntries(
+    Object.entries(variants).map(([key, value]) => [key, Object.keys(value)])
+  );
+  return Object.assign(memo(svaFn), {
+    __cva__: false,
+    raw,
+    variantMap,
+    variantKeys,
+    splitVariantProps,
+    getVariantProps
+  });
+}
+var userGeneratedStr = "css,pos,insetX,insetY,insetEnd,end,insetStart,start,flexDir,p,pl,pr,pt,pb,py,paddingY,paddingX,px,pe,paddingEnd,ps,paddingStart,ml,mr,mt,mb,m,my,marginY,mx,marginX,me,marginEnd,ms,marginStart,ringWidth,ringColor,ring,ringOffset,w,minW,maxW,h,minH,maxH,textShadowColor,bgPosition,bgPositionX,bgPositionY,bgAttachment,bgClip,bg,bgColor,bgOrigin,bgImage,bgRepeat,bgBlendMode,bgSize,bgGradient,rounded,roundedTopLeft,roundedTopRight,roundedBottomRight,roundedBottomLeft,roundedTop,roundedRight,roundedBottom,roundedLeft,roundedStartStart,roundedStartEnd,roundedStart,roundedEndStart,roundedEndEnd,roundedEnd,borderX,borderXWidth,borderXColor,borderY,borderYWidth,borderYColor,borderStart,borderStartWidth,borderStartColor,borderEnd,borderEndWidth,borderEndColor,shadow,shadowColor,x,y,z,scrollMarginY,scrollMarginX,scrollPaddingY,scrollPaddingX,aspectRatio,boxDecorationBreak,zIndex,boxSizing,objectPosition,objectFit,overscrollBehavior,overscrollBehaviorX,overscrollBehaviorY,position,top,left,inset,insetInline,insetBlock,insetBlockEnd,insetBlockStart,insetInlineEnd,insetInlineStart,right,bottom,float,visibility,display,hideFrom,hideBelow,flexBasis,flex,flexDirection,flexGrow,flexShrink,gridTemplateColumns,gridTemplateRows,gridColumn,gridRow,gridColumnStart,gridColumnEnd,gridAutoFlow,gridAutoColumns,gridAutoRows,gap,gridGap,gridRowGap,gridColumnGap,rowGap,columnGap,justifyContent,alignContent,alignItems,alignSelf,padding,paddingLeft,paddingRight,paddingTop,paddingBottom,paddingBlock,paddingBlockEnd,paddingBlockStart,paddingInline,paddingInlineEnd,paddingInlineStart,marginLeft,marginRight,marginTop,marginBottom,margin,marginBlock,marginBlockEnd,marginBlockStart,marginInline,marginInlineEnd,marginInlineStart,spaceX,spaceY,outlineWidth,outlineColor,outline,outlineOffset,divideX,divideY,divideColor,divideStyle,width,inlineSize,minWidth,minInlineSize,maxWidth,maxInlineSize,height,blockSize,minHeight,minBlockSize,maxHeight,maxBlockSize,color,fontFamily,fontSize,fontSizeAdjust,fontPalette,fontKerning,fontFeatureSettings,fontWeight,fontSmoothing,fontVariant,fontVariantAlternates,fontVariantCaps,fontVariationSettings,fontVariantNumeric,letterSpacing,lineHeight,textAlign,textDecoration,textDecorationColor,textEmphasisColor,textDecorationStyle,textDecorationThickness,textUnderlineOffset,textTransform,textIndent,textShadow,textOverflow,verticalAlign,wordBreak,textWrap,truncate,lineClamp,listStyleType,listStylePosition,listStyleImage,listStyle,backgroundPosition,backgroundPositionX,backgroundPositionY,backgroundAttachment,backgroundClip,background,backgroundColor,backgroundOrigin,backgroundImage,backgroundRepeat,backgroundBlendMode,backgroundSize,backgroundGradient,textGradient,gradientFromPosition,gradientToPosition,gradientFrom,gradientTo,gradientVia,gradientViaPosition,borderRadius,borderTopLeftRadius,borderTopRightRadius,borderBottomRightRadius,borderBottomLeftRadius,borderTopRadius,borderRightRadius,borderBottomRadius,borderLeftRadius,borderStartStartRadius,borderStartEndRadius,borderStartRadius,borderEndStartRadius,borderEndEndRadius,borderEndRadius,border,borderWidth,borderTopWidth,borderLeftWidth,borderRightWidth,borderBottomWidth,borderColor,borderInline,borderInlineWidth,borderInlineColor,borderBlock,borderBlockWidth,borderBlockColor,borderLeft,borderLeftColor,borderInlineStart,borderInlineStartWidth,borderInlineStartColor,borderRight,borderRightColor,borderInlineEnd,borderInlineEndWidth,borderInlineEndColor,borderTop,borderTopColor,borderBottom,borderBottomColor,borderBlockEnd,borderBlockEndColor,borderBlockStart,borderBlockStartColor,opacity,boxShadow,boxShadowColor,mixBlendMode,filter,brightness,contrast,grayscale,hueRotate,invert,saturate,sepia,dropShadow,blur,backdropFilter,backdropBlur,backdropBrightness,backdropContrast,backdropGrayscale,backdropHueRotate,backdropInvert,backdropOpacity,backdropSaturate,backdropSepia,borderCollapse,borderSpacing,borderSpacingX,borderSpacingY,tableLayout,transitionTimingFunction,transitionDelay,transitionDuration,transitionProperty,transition,animation,animationName,animationTimingFunction,animationDuration,animationDelay,animationPlayState,animationComposition,animationFillMode,animationDirection,animationIterationCount,animationRange,animationState,animationRangeStart,animationRangeEnd,animationTimeline,transformOrigin,transformBox,transformStyle,transform,rotate,rotateX,rotateY,rotateZ,scale,scaleX,scaleY,translate,translateX,translateY,translateZ,accentColor,caretColor,scrollBehavior,scrollbar,scrollbarColor,scrollbarGutter,scrollbarWidth,scrollMargin,scrollMarginLeft,scrollMarginRight,scrollMarginTop,scrollMarginBottom,scrollMarginBlock,scrollMarginBlockEnd,scrollMarginBlockStart,scrollMarginInline,scrollMarginInlineEnd,scrollMarginInlineStart,scrollPadding,scrollPaddingBlock,scrollPaddingBlockStart,scrollPaddingBlockEnd,scrollPaddingInline,scrollPaddingInlineEnd,scrollPaddingInlineStart,scrollPaddingLeft,scrollPaddingRight,scrollPaddingTop,scrollPaddingBottom,scrollSnapAlign,scrollSnapStop,scrollSnapType,scrollSnapStrictness,scrollSnapMargin,scrollSnapMarginTop,scrollSnapMarginBottom,scrollSnapMarginLeft,scrollSnapMarginRight,scrollSnapCoordinate,scrollSnapDestination,scrollSnapPointsX,scrollSnapPointsY,scrollSnapTypeX,scrollSnapTypeY,scrollTimeline,scrollTimelineAxis,scrollTimelineName,touchAction,userSelect,overflow,overflowWrap,overflowX,overflowY,overflowAnchor,overflowBlock,overflowInline,overflowClipBox,overflowClipMargin,overscrollBehaviorBlock,overscrollBehaviorInline,fill,stroke,strokeWidth,strokeDasharray,strokeDashoffset,strokeLinecap,strokeLinejoin,strokeMiterlimit,strokeOpacity,srOnly,debug,appearance,backfaceVisibility,clipPath,hyphens,mask,maskImage,maskSize,textSizeAdjust,container,containerName,containerType,colorPalette,_hover,_focus,_focusWithin,_focusVisible,_disabled,_active,_visited,_target,_readOnly,_readWrite,_empty,_checked,_enabled,_expanded,_highlighted,_complete,_incomplete,_dragging,_before,_after,_firstLetter,_firstLine,_marker,_selection,_file,_backdrop,_first,_last,_only,_even,_odd,_firstOfType,_lastOfType,_onlyOfType,_peerFocus,_peerHover,_peerActive,_peerFocusWithin,_peerFocusVisible,_peerDisabled,_peerChecked,_peerInvalid,_peerExpanded,_peerPlaceholderShown,_groupFocus,_groupHover,_groupActive,_groupFocusWithin,_groupFocusVisible,_groupDisabled,_groupChecked,_groupExpanded,_groupInvalid,_indeterminate,_required,_valid,_invalid,_autofill,_inRange,_outOfRange,_placeholder,_placeholderShown,_pressed,_selected,_grabbed,_underValue,_overValue,_atValue,_default,_optional,_open,_closed,_fullscreen,_loading,_hidden,_current,_currentPage,_currentStep,_today,_unavailable,_rangeStart,_rangeEnd,_now,_topmost,_motionReduce,_motionSafe,_print,_landscape,_portrait,_dark,_light,_osDark,_osLight,_highContrast,_lessContrast,_moreContrast,_ltr,_rtl,_scrollbar,_scrollbarThumb,_scrollbarTrack,_horizontal,_vertical,_icon,_starting,_collapsed,_off,_on,sm,smOnly,smDown,md,mdOnly,mdDown,lg,lgOnly,lgDown,xl,xlOnly,xlDown,2xl,2xlOnly,2xlDown,smToMd,smToLg,smToXl,smTo2xl,mdToLg,mdToXl,mdTo2xl,lgToXl,lgTo2xl,xlTo2xl,textStyle";
+var userGenerated = userGeneratedStr.split(",");
+var cssPropertiesStr = "WebkitAppearance,WebkitBorderBefore,WebkitBorderBeforeColor,WebkitBorderBeforeStyle,WebkitBorderBeforeWidth,WebkitBoxReflect,WebkitLineClamp,WebkitMask,WebkitMaskAttachment,WebkitMaskClip,WebkitMaskComposite,WebkitMaskImage,WebkitMaskOrigin,WebkitMaskPosition,WebkitMaskPositionX,WebkitMaskPositionY,WebkitMaskRepeat,WebkitMaskRepeatX,WebkitMaskRepeatY,WebkitMaskSize,WebkitOverflowScrolling,WebkitTapHighlightColor,WebkitTextFillColor,WebkitTextStroke,WebkitTextStrokeColor,WebkitTextStrokeWidth,WebkitTouchCallout,WebkitUserModify,WebkitUserSelect,accentColor,alignContent,alignItems,alignSelf,alignTracks,all,anchorName,anchorScope,animation,animationComposition,animationDelay,animationDirection,animationDuration,animationFillMode,animationIterationCount,animationName,animationPlayState,animationRange,animationRangeEnd,animationRangeStart,animationTimeline,animationTimingFunction,appearance,aspectRatio,backdropFilter,backfaceVisibility,background,backgroundAttachment,backgroundBlendMode,backgroundClip,backgroundColor,backgroundImage,backgroundOrigin,backgroundPosition,backgroundPositionX,backgroundPositionY,backgroundRepeat,backgroundSize,blockSize,border,borderBlock,borderBlockColor,borderBlockEnd,borderBlockEndColor,borderBlockEndStyle,borderBlockEndWidth,borderBlockStart,borderBlockStartColor,borderBlockStartStyle,borderBlockStartWidth,borderBlockStyle,borderBlockWidth,borderBottom,borderBottomColor,borderBottomLeftRadius,borderBottomRightRadius,borderBottomStyle,borderBottomWidth,borderCollapse,borderColor,borderEndEndRadius,borderEndStartRadius,borderImage,borderImageOutset,borderImageRepeat,borderImageSlice,borderImageSource,borderImageWidth,borderInline,borderInlineColor,borderInlineEnd,borderInlineEndColor,borderInlineEndStyle,borderInlineEndWidth,borderInlineStart,borderInlineStartColor,borderInlineStartStyle,borderInlineStartWidth,borderInlineStyle,borderInlineWidth,borderLeft,borderLeftColor,borderLeftStyle,borderLeftWidth,borderRadius,borderRight,borderRightColor,borderRightStyle,borderRightWidth,borderSpacing,borderStartEndRadius,borderStartStartRadius,borderStyle,borderTop,borderTopColor,borderTopLeftRadius,borderTopRightRadius,borderTopStyle,borderTopWidth,borderWidth,bottom,boxAlign,boxDecorationBreak,boxDirection,boxFlex,boxFlexGroup,boxLines,boxOrdinalGroup,boxOrient,boxPack,boxShadow,boxSizing,breakAfter,breakBefore,breakInside,captionSide,caret,caretColor,caretShape,clear,clip,clipPath,clipRule,color,colorInterpolationFilters,colorScheme,columnCount,columnFill,columnGap,columnRule,columnRuleColor,columnRuleStyle,columnRuleWidth,columnSpan,columnWidth,columns,contain,containIntrinsicBlockSize,containIntrinsicHeight,containIntrinsicInlineSize,containIntrinsicSize,containIntrinsicWidth,container,containerName,containerType,content,contentVisibility,counterIncrement,counterReset,counterSet,cursor,cx,cy,d,direction,display,dominantBaseline,emptyCells,fieldSizing,fill,fillOpacity,fillRule,filter,flex,flexBasis,flexDirection,flexFlow,flexGrow,flexShrink,flexWrap,float,floodColor,floodOpacity,font,fontFamily,fontFeatureSettings,fontKerning,fontLanguageOverride,fontOpticalSizing,fontPalette,fontSize,fontSizeAdjust,fontSmooth,fontStretch,fontStyle,fontSynthesis,fontSynthesisPosition,fontSynthesisSmallCaps,fontSynthesisStyle,fontSynthesisWeight,fontVariant,fontVariantAlternates,fontVariantCaps,fontVariantEastAsian,fontVariantEmoji,fontVariantLigatures,fontVariantNumeric,fontVariantPosition,fontVariationSettings,fontWeight,forcedColorAdjust,gap,grid,gridArea,gridAutoColumns,gridAutoFlow,gridAutoRows,gridColumn,gridColumnEnd,gridColumnGap,gridColumnStart,gridGap,gridRow,gridRowEnd,gridRowGap,gridRowStart,gridTemplate,gridTemplateAreas,gridTemplateColumns,gridTemplateRows,hangingPunctuation,height,hyphenateCharacter,hyphenateLimitChars,hyphens,imageOrientation,imageRendering,imageResolution,imeMode,initialLetter,initialLetterAlign,inlineSize,inset,insetBlock,insetBlockEnd,insetBlockStart,insetInline,insetInlineEnd,insetInlineStart,interpolateSize,isolation,justifyContent,justifyItems,justifySelf,justifyTracks,left,letterSpacing,lightingColor,lineBreak,lineClamp,lineHeight,lineHeightStep,listStyle,listStyleImage,listStylePosition,listStyleType,margin,marginBlock,marginBlockEnd,marginBlockStart,marginBottom,marginInline,marginInlineEnd,marginInlineStart,marginLeft,marginRight,marginTop,marginTrim,marker,markerEnd,markerMid,markerStart,mask,maskBorder,maskBorderMode,maskBorderOutset,maskBorderRepeat,maskBorderSlice,maskBorderSource,maskBorderWidth,maskClip,maskComposite,maskImage,maskMode,maskOrigin,maskPosition,maskRepeat,maskSize,maskType,masonryAutoFlow,mathDepth,mathShift,mathStyle,maxBlockSize,maxHeight,maxInlineSize,maxLines,maxWidth,minBlockSize,minHeight,minInlineSize,minWidth,mixBlendMode,objectFit,objectPosition,offset,offsetAnchor,offsetDistance,offsetPath,offsetPosition,offsetRotate,opacity,order,orphans,outline,outlineColor,outlineOffset,outlineStyle,outlineWidth,overflow,overflowAnchor,overflowBlock,overflowClipBox,overflowClipMargin,overflowInline,overflowWrap,overflowX,overflowY,overlay,overscrollBehavior,overscrollBehaviorBlock,overscrollBehaviorInline,overscrollBehaviorX,overscrollBehaviorY,padding,paddingBlock,paddingBlockEnd,paddingBlockStart,paddingBottom,paddingInline,paddingInlineEnd,paddingInlineStart,paddingLeft,paddingRight,paddingTop,page,pageBreakAfter,pageBreakBefore,pageBreakInside,paintOrder,perspective,perspectiveOrigin,placeContent,placeItems,placeSelf,pointerEvents,position,positionAnchor,positionArea,positionTry,positionTryFallbacks,positionTryOrder,positionVisibility,printColorAdjust,quotes,r,resize,right,rotate,rowGap,rubyAlign,rubyMerge,rubyPosition,rx,ry,scale,scrollBehavior,scrollMargin,scrollMarginBlock,scrollMarginBlockEnd,scrollMarginBlockStart,scrollMarginBottom,scrollMarginInline,scrollMarginInlineEnd,scrollMarginInlineStart,scrollMarginLeft,scrollMarginRight,scrollMarginTop,scrollPadding,scrollPaddingBlock,scrollPaddingBlockEnd,scrollPaddingBlockStart,scrollPaddingBottom,scrollPaddingInline,scrollPaddingInlineEnd,scrollPaddingInlineStart,scrollPaddingLeft,scrollPaddingRight,scrollPaddingTop,scrollSnapAlign,scrollSnapCoordinate,scrollSnapDestination,scrollSnapPointsX,scrollSnapPointsY,scrollSnapStop,scrollSnapType,scrollSnapTypeX,scrollSnapTypeY,scrollTimeline,scrollTimelineAxis,scrollTimelineName,scrollbarColor,scrollbarGutter,scrollbarWidth,shapeImageThreshold,shapeMargin,shapeOutside,shapeRendering,stopColor,stopOpacity,stroke,strokeDasharray,strokeDashoffset,strokeLinecap,strokeLinejoin,strokeMiterlimit,strokeOpacity,strokeWidth,tabSize,tableLayout,textAlign,textAlignLast,textAnchor,textBox,textBoxEdge,textBoxTrim,textCombineUpright,textDecoration,textDecorationColor,textDecorationLine,textDecorationSkip,textDecorationSkipInk,textDecorationStyle,textDecorationThickness,textEmphasis,textEmphasisColor,textEmphasisPosition,textEmphasisStyle,textIndent,textJustify,textOrientation,textOverflow,textRendering,textShadow,textSizeAdjust,textSpacingTrim,textTransform,textUnderlineOffset,textUnderlinePosition,textWrap,textWrapMode,textWrapStyle,timelineScope,top,touchAction,transform,transformBox,transformOrigin,transformStyle,transition,transitionBehavior,transitionDelay,transitionDuration,transitionProperty,transitionTimingFunction,translate,unicodeBidi,userSelect,vectorEffect,verticalAlign,viewTimeline,viewTimelineAxis,viewTimelineInset,viewTimelineName,viewTransitionName,visibility,whiteSpace,whiteSpaceCollapse,widows,width,willChange,wordBreak,wordSpacing,wordWrap,writingMode,x,y,zIndex,zoom,alignmentBaseline,baselineShift,colorInterpolation,colorRendering,glyphOrientationVertical";
+var allCssProperties = cssPropertiesStr.split(",").concat(userGenerated);
+var properties = new Map(allCssProperties.map((prop) => [prop, true]));
+var cssPropertySelectorRegex = /&|@/;
+var isCssProperty = /* @__PURE__ */ memo((prop) => {
+  return properties.has(prop) || prop.startsWith("--") || cssPropertySelectorRegex.test(prop);
+});
+const defaultShouldForwardProp = (prop, variantKeys) => !variantKeys.includes(prop) && !isCssProperty(prop);
+const composeShouldForwardProps = (tag, shouldForwardProp2) => tag.__shouldForwardProps__ && shouldForwardProp2 ? (propName) => tag.__shouldForwardProps__(propName) && shouldForwardProp2(propName) : shouldForwardProp2;
+const composeCvaFn = (cvaA, cvaB) => {
+  var _a;
+  if (cvaA && !cvaB) return cvaA;
+  if (!cvaA && cvaB) return cvaB;
+  if (cvaA.__cva__ && cvaB.__cva__ || cvaA.__recipe__ && cvaB.__recipe__) return cvaA.merge(cvaB);
+  const error = new TypeError("Cannot merge cva with recipe. Please use either cva or recipe.");
+  (_a = TypeError.captureStackTrace) == null ? void 0 : _a.call(TypeError, error);
+  throw error;
+};
+const getDisplayName = (Component) => {
+  if (typeof Component === "string") return Component;
+  return (Component == null ? void 0 : Component.displayName) || (Component == null ? void 0 : Component.name) || "Component";
+};
+function styledFn(Dynamic, configOrCva = {}, options = {}) {
+  const cvaFn = configOrCva.__cva__ || configOrCva.__recipe__ ? configOrCva : cva(configOrCva);
+  const forwardFn = options.shouldForwardProp || defaultShouldForwardProp;
+  const shouldForwardProp2 = (prop) => forwardFn(prop, cvaFn.variantKeys);
+  const defaultProps = Object.assign(
+    options.dataAttr && configOrCva.__name__ ? { "data-recipe": configOrCva.__name__ } : {},
+    options.defaultProps
+  );
+  const __cvaFn__ = composeCvaFn(Dynamic.__cva__, cvaFn);
+  const __shouldForwardProps__ = composeShouldForwardProps(Dynamic, shouldForwardProp2);
+  const __base__ = Dynamic.__base__ || Dynamic;
+  const StyledComponent = /* @__PURE__ */ React.forwardRef(function StyledComponent2(props, ref) {
+    const { as: Element = __base__, children, ...restProps } = props;
+    const combinedProps = React.useMemo(() => Object.assign({}, defaultProps, restProps), [restProps]);
+    const [htmlProps2, forwardedProps, variantProps, styleProps, elementProps] = React.useMemo(() => {
+      return splitProps(combinedProps, normalizeHTMLProps.keys, __shouldForwardProps__, __cvaFn__.variantKeys, isCssProperty);
+    }, [combinedProps]);
+    function recipeClass() {
+      var _a;
+      const { css: cssStyles, ...propStyles } = styleProps;
+      const compoundVariantStyles = (_a = __cvaFn__.__getCompoundVariantCss__) == null ? void 0 : _a.call(__cvaFn__, variantProps);
+      return cx(__cvaFn__(variantProps, false), css$1(compoundVariantStyles, propStyles, cssStyles), combinedProps.className);
+    }
+    function cvaClass() {
+      const { css: cssStyles, ...propStyles } = styleProps;
+      const cvaStyles = __cvaFn__.raw(variantProps);
+      return cx(css$1(cvaStyles, propStyles, cssStyles), combinedProps.className);
+    }
+    const classes = configOrCva.__recipe__ ? recipeClass : cvaClass;
+    return React.createElement(Element, {
+      ref,
+      ...forwardedProps,
+      ...elementProps,
+      ...normalizeHTMLProps(htmlProps2),
+      className: classes()
+    }, combinedProps.children ?? children);
+  });
+  const name = getDisplayName(__base__);
+  StyledComponent.displayName = `styled.${name}`;
+  StyledComponent.__cva__ = __cvaFn__;
+  StyledComponent.__base__ = __base__;
+  StyledComponent.__shouldForwardProps__ = shouldForwardProp2;
+  return StyledComponent;
+}
+function createJsxFactory() {
+  const cache = /* @__PURE__ */ new Map();
+  return new Proxy(styledFn, {
+    apply(_, __, args) {
+      return styledFn(...args);
+    },
+    get(_, el) {
+      if (!cache.has(el)) {
+        cache.set(el, styledFn(el));
+      }
+      return cache.get(el);
+    }
+  });
+}
+const styled = /* @__PURE__ */ createJsxFactory();
+const centerConfig = {
+  transform(props) {
+    const { inline, ...rest } = props;
+    return {
+      display: inline ? "inline-flex" : "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      ...rest
+    };
+  }
+};
+const getCenterStyle = (styles = {}) => {
+  const _styles = getPatternStyles(centerConfig, styles);
+  return centerConfig.transform(_styles, patternFns);
+};
+const Center = /* @__PURE__ */ React.forwardRef(function Center2(props, ref) {
+  const [patternProps, restProps] = splitProps(props, ["inline"]);
+  const styleProps = getCenterStyle(patternProps);
+  const mergedProps = { ref, ...styleProps, ...restProps };
+  return React.createElement(styled.div, mergedProps);
+});
+function getErrorMessage(hook, provider) {
+  return `${hook} returned \`undefined\`. Seems you forgot to wrap component within ${provider}`;
+}
+function createContext(options = {}) {
+  const {
+    name,
+    strict = true,
+    hookName = "useContext",
+    providerName = "Provider",
+    errorMessage,
+    defaultValue
+  } = options;
+  const Context = React.createContext(defaultValue);
+  Context.displayName = name;
+  function useContext$1() {
+    var _a;
+    const context2 = React.useContext(Context);
+    if (!context2 && strict) {
+      const error = new Error(errorMessage ?? getErrorMessage(hookName, providerName));
+      error.name = "ContextError";
+      (_a = Error.captureStackTrace) == null ? void 0 : _a.call(Error, error, useContext$1);
+      throw error;
+    }
+    return context2;
+  }
+  return [Context.Provider, useContext$1, Context];
+}
+function toArray(v2) {
+  if (!v2) return [];
+  return Array.isArray(v2) ? v2 : [v2];
+}
+var isString = (v2) => typeof v2 === "string";
+var isFunction = (v2) => typeof v2 === "function";
+var fnToString = Function.prototype.toString;
+fnToString.call(Object);
+var identity = (v2) => v2();
+var callAll = (...fns2) => (...a) => {
+  fns2.forEach(function(fn) {
+    fn == null ? void 0 : fn(...a);
+  });
+};
+function compact(obj) {
+  if (!isPlainObject2(obj) || obj === void 0) return obj;
+  const keys = Reflect.ownKeys(obj).filter((key) => typeof key === "string");
+  const filtered = {};
+  for (const key of keys) {
+    const value = obj[key];
+    if (value !== void 0) {
+      filtered[key] = compact(value);
+    }
+  }
+  return filtered;
+}
+var isPlainObject2 = (v2) => {
+  return v2 && typeof v2 === "object" && v2.constructor === Object;
+};
+function warn(...a) {
+  const m2 = a.length === 1 ? a[0] : a[1];
+  const c = a.length === 2 ? a[0] : true;
+  if (c && process.env.NODE_ENV !== "production") {
+    console.warn(m2);
+  }
+}
+function ensure(c, m2) {
+  if (c == null) throw new Error(m2);
+}
+var isObject = (v2) => typeof v2 === "object" && v2 !== null;
+var ELEMENT_NODE = 1;
+var DOCUMENT_NODE = 9;
+var DOCUMENT_FRAGMENT_NODE = 11;
+var isHTMLElement = (el) => isObject(el) && el.nodeType === ELEMENT_NODE && typeof el.nodeName === "string";
+var isDocument = (el) => isObject(el) && el.nodeType === DOCUMENT_NODE;
+var isWindow = (el) => isObject(el) && el === el.window;
+var getNodeName = (node) => {
+  if (isHTMLElement(node)) return node.localName || "";
+  return "#document";
+};
+function isRootElement(node) {
+  return ["html", "body", "#document"].includes(getNodeName(node));
+}
+var isNode = (el) => isObject(el) && el.nodeType !== void 0;
+var isShadowRoot = (el) => isNode(el) && el.nodeType === DOCUMENT_FRAGMENT_NODE && "host" in el;
+var isInputElement = (el) => isHTMLElement(el) && el.localName === "input";
+var isElementVisible = (el) => {
+  if (!isHTMLElement(el)) return false;
+  return el.offsetWidth > 0 || el.offsetHeight > 0 || el.getClientRects().length > 0;
+};
+var TEXTAREA_SELECT_REGEX = /(textarea|select)/;
+function isEditableElement(el) {
+  if (el == null || !isHTMLElement(el)) return false;
+  try {
+    return isInputElement(el) && el.selectionStart != null || TEXTAREA_SELECT_REGEX.test(el.localName) || el.isContentEditable || el.getAttribute("contenteditable") === "true" || el.getAttribute("contenteditable") === "";
+  } catch {
+    return false;
+  }
+}
+function contains(parent, child) {
+  var _a;
+  if (!parent || !child) return false;
+  if (!isHTMLElement(parent) || !isHTMLElement(child)) return false;
+  const rootNode = (_a = child.getRootNode) == null ? void 0 : _a.call(child);
+  if (parent === child) return true;
+  if (parent.contains(child)) return true;
+  if (rootNode && isShadowRoot(rootNode)) {
+    let next = child;
+    while (next) {
+      if (parent === next) return true;
+      next = next.parentNode || next.host;
+    }
+  }
+  return false;
+}
+function getDocument(el) {
+  if (isDocument(el)) return el;
+  if (isWindow(el)) return el.document;
+  return (el == null ? void 0 : el.ownerDocument) ?? document;
+}
+function getDocumentElement(el) {
+  return getDocument(el).documentElement;
+}
+function getWindow(el) {
+  var _a;
+  if (isShadowRoot(el)) return getWindow(el.host);
+  if (isDocument(el)) return el.defaultView ?? window;
+  if (isHTMLElement(el)) return ((_a = el.ownerDocument) == null ? void 0 : _a.defaultView) ?? window;
+  return window;
+}
+function getActiveElement(rootNode) {
+  let activeElement = rootNode.activeElement;
+  while (activeElement == null ? void 0 : activeElement.shadowRoot) {
+    const el = activeElement.shadowRoot.activeElement;
+    if (el === activeElement) break;
+    else activeElement = el;
+  }
+  return activeElement;
+}
+function getParentNode$1(node) {
+  if (getNodeName(node) === "html") return node;
+  const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
+  return isShadowRoot(result) ? result.host : result;
+}
+var styleCache = /* @__PURE__ */ new WeakMap();
+function getComputedStyle(el) {
+  if (!styleCache.has(el)) {
+    styleCache.set(el, getWindow(el).getComputedStyle(el));
+  }
+  return styleCache.get(el);
+}
+var isDom = () => typeof document !== "undefined";
+function getPlatform() {
+  const agent = navigator.userAgentData;
+  return (agent == null ? void 0 : agent.platform) ?? navigator.platform;
+}
+var pt = (v2) => isDom() && v2.test(getPlatform());
+var isMac = () => pt(/^Mac/);
+var isIos = () => pt(/iP(hone|ad|od)|iOS/);
+function getComposedPath(event) {
+  var _a, _b, _c;
+  return ((_a = event.composedPath) == null ? void 0 : _a.call(event)) ?? ((_c = (_b = event.nativeEvent) == null ? void 0 : _b.composedPath) == null ? void 0 : _c.call(_b));
+}
+function getEventTarget(event) {
+  const composedPath = getComposedPath(event);
+  return (composedPath == null ? void 0 : composedPath[0]) ?? event.target;
+}
+var isContextMenuEvent = (e) => {
+  return e.button === 2 || isMac() && e.ctrlKey && e.button === 0;
+};
+var addDomEvent = (target, eventName, handler, options) => {
+  const node = typeof target === "function" ? target() : target;
+  node == null ? void 0 : node.addEventListener(eventName, handler, options);
+  return () => {
+    node == null ? void 0 : node.removeEventListener(eventName, handler, options);
+  };
+};
+var isFrame = (el) => isHTMLElement(el) && el.tagName === "IFRAME";
+var hasTabIndex = (el) => !Number.isNaN(parseInt(el.getAttribute("tabindex") || "0", 10));
+var hasNegativeTabIndex = (el) => parseInt(el.getAttribute("tabindex") || "0", 10) < 0;
+var focusableSelector = "input:not([type='hidden']):not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], button:not([disabled]), [tabindex], iframe, object, embed, area[href], audio[controls], video[controls], [contenteditable]:not([contenteditable='false']), details > summary:first-of-type";
+var getFocusables = (container, includeContainer = false) => {
+  if (!container) return [];
+  const elements = Array.from(container.querySelectorAll(focusableSelector));
+  const include = includeContainer == true || includeContainer == "if-empty" && elements.length === 0;
+  if (include && isHTMLElement(container) && isFocusable(container)) {
+    elements.unshift(container);
+  }
+  const focusableElements = elements.filter(isFocusable);
+  focusableElements.forEach((element, i) => {
+    if (isFrame(element) && element.contentDocument) {
+      const frameBody = element.contentDocument.body;
+      focusableElements.splice(i, 1, ...getFocusables(frameBody));
+    }
+  });
+  return focusableElements;
+};
+function isFocusable(element) {
+  if (!element || element.closest("[inert]")) return false;
+  return element.matches(focusableSelector) && isElementVisible(element);
+}
+function getTabbables(container, includeContainer) {
+  if (!container) return [];
+  const elements = Array.from(container.querySelectorAll(focusableSelector));
+  const tabbableElements = elements.filter(isTabbable);
+  tabbableElements.forEach((element, i) => {
+    if (isFrame(element) && element.contentDocument) {
+      const frameBody = element.contentDocument.body;
+      const allFrameTabbable = getTabbables(frameBody);
+      tabbableElements.splice(i, 1, ...allFrameTabbable);
+    }
+  });
+  if (!tabbableElements.length && includeContainer) ;
+  return tabbableElements;
+}
+function isTabbable(el) {
+  if (el != null && el.tabIndex > 0) return true;
+  return isFocusable(el) && !hasNegativeTabIndex(el);
+}
+function getTabIndex(node) {
+  if (node.tabIndex < 0) {
+    if ((/^(audio|video|details)$/.test(node.localName) || isEditableElement(node)) && !hasTabIndex(node)) {
+      return 0;
+    }
+  }
+  return node.tabIndex;
+}
+function nextTick(fn) {
+  const set2 = /* @__PURE__ */ new Set();
+  function raf2(fn2) {
+    const id = globalThis.requestAnimationFrame(fn2);
+    set2.add(() => globalThis.cancelAnimationFrame(id));
+  }
+  raf2(() => raf2(fn));
+  return function cleanup() {
+    set2.forEach((fn2) => fn2());
+  };
+}
+function raf$1(fn) {
+  let cleanup;
+  const id = globalThis.requestAnimationFrame(() => {
+    cleanup = fn();
+  });
+  return () => {
+    globalThis.cancelAnimationFrame(id);
+    cleanup == null ? void 0 : cleanup();
+  };
+}
+function getNearestOverflowAncestor(el) {
+  const parentNode = getParentNode$1(el);
+  if (isRootElement(parentNode)) return getDocument(parentNode).body;
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) return parentNode;
+  return getNearestOverflowAncestor(parentNode);
+}
+var OVERFLOW_RE = /auto|scroll|overlay|hidden|clip/;
+function isOverflowElement(el) {
+  const win = getWindow(el);
+  const { overflow, overflowX, overflowY, display } = win.getComputedStyle(el);
+  return OVERFLOW_RE.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
+}
+var cleanups = /* @__PURE__ */ new WeakMap();
+function set(element, key, setup) {
+  if (!cleanups.has(element)) {
+    cleanups.set(element, /* @__PURE__ */ new Map());
+  }
+  const elementCleanups = cleanups.get(element);
+  const prevCleanup = elementCleanups.get(key);
+  if (!prevCleanup) {
+    elementCleanups.set(key, setup());
+    return () => {
+      var _a;
+      (_a = elementCleanups.get(key)) == null ? void 0 : _a();
+      elementCleanups.delete(key);
+    };
+  }
+  const cleanup = setup();
+  const nextCleanup = () => {
+    cleanup();
+    prevCleanup();
+    elementCleanups.delete(key);
+  };
+  elementCleanups.set(key, nextCleanup);
+  return () => {
+    const isCurrent = elementCleanups.get(key) === nextCleanup;
+    if (!isCurrent) return;
+    cleanup();
+    elementCleanups.set(key, prevCleanup);
+  };
+}
+function setStyle(element, style) {
+  if (!element) return () => {
+  };
+  const setup = () => {
+    const prevStyle = element.style.cssText;
+    Object.assign(element.style, style);
+    return () => {
+      element.style.cssText = prevStyle;
+    };
+  };
+  return set(element, "style", setup);
+}
+var fps = 1e3 / 60;
+function waitForElement(query2, cb) {
+  const el = query2();
+  if (isHTMLElement(el) && el.isConnected) {
+    cb(el);
+    return () => void 0;
+  } else {
+    const timerId = setInterval(() => {
+      const el2 = query2();
+      if (isHTMLElement(el2) && el2.isConnected) {
+        cb(el2);
+        clearInterval(timerId);
+      }
+    }, fps);
+    return () => clearInterval(timerId);
+  }
+}
+function waitForElements(queries, cb) {
+  const cleanups2 = [];
+  queries == null ? void 0 : queries.forEach((query2) => {
+    const clean = waitForElement(query2, cb);
+    cleanups2.push(clean);
+  });
+  return () => {
+    cleanups2.forEach((fn) => fn());
+  };
+}
+var clsx = (...args) => args.map((str) => {
+  var _a;
+  return (_a = str == null ? void 0 : str.trim) == null ? void 0 : _a.call(str);
+}).filter(Boolean).join(" ");
+var CSS_REGEX = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g;
+var serialize = (style) => {
+  const res = {};
+  let match;
+  while (match = CSS_REGEX.exec(style)) {
+    res[match[1]] = match[2];
+  }
+  return res;
+};
+var css = (a, b) => {
+  if (isString(a)) {
+    if (isString(b)) return `${a};${b}`;
+    a = serialize(a);
+  } else if (isString(b)) {
+    b = serialize(b);
+  }
+  return Object.assign({}, a ?? {}, b ?? {});
+};
+function mergeProps(...args) {
+  let result = {};
+  for (let props of args) {
+    for (let key in result) {
+      if (key.startsWith("on") && typeof result[key] === "function" && typeof props[key] === "function") {
+        result[key] = callAll(props[key], result[key]);
+        continue;
+      }
+      if (key === "className" || key === "class") {
+        result[key] = clsx(result[key], props[key]);
+        continue;
+      }
+      if (key === "style") {
+        result[key] = css(result[key], props[key]);
+        continue;
+      }
+      result[key] = props[key] !== void 0 ? props[key] : result[key];
+    }
+    for (let key in props) {
+      if (result[key] === void 0) {
+        result[key] = props[key];
+      }
+    }
+  }
+  return result;
+}
+function createMachine(config) {
+  return config;
+}
+function createScope(props) {
+  const getRootNode = () => {
+    var _a;
+    return ((_a = props.getRootNode) == null ? void 0 : _a.call(props)) ?? document;
+  };
+  const getDoc = () => getDocument(getRootNode());
+  const getWin = () => getDoc().defaultView ?? window;
+  const getActiveElementFn = () => getActiveElement(getRootNode());
+  const isActiveElement = (elem) => elem === getActiveElementFn();
+  const getById = (id) => getRootNode().getElementById(id);
+  return {
+    ...props,
+    getRootNode,
+    getDoc,
+    getWin,
+    getActiveElement: getActiveElementFn,
+    isActiveElement,
+    getById
+  };
+}
+function createNormalizer(fn) {
+  return new Proxy({}, {
+    get(_target, key) {
+      if (key === "style")
+        return (props) => {
+          return fn({ style: props }).style;
+        };
+      return fn;
+    }
+  });
+}
+var createProps = () => (props) => Array.from(new Set(props));
+var useSafeLayoutEffect = typeof globalThis.document !== "undefined" ? React.useLayoutEffect : React.useEffect;
+function useBindable(props) {
+  const initial = props().value ?? props().defaultValue;
+  const eq = props().isEqual ?? Object.is;
+  const [initialValue] = React.useState(initial);
+  const [value, setValue] = React.useState(initialValue);
+  const controlled = props().value !== void 0;
+  const valueRef = React.useRef(value);
+  valueRef.current = controlled ? props().value : value;
+  const prevValue = React.useRef(valueRef.current);
+  useSafeLayoutEffect(() => {
+    prevValue.current = valueRef.current;
+  }, [value, props().value]);
+  const setFn = (value2) => {
+    var _a, _b;
+    const prev = prevValue.current;
+    const next = isFunction(value2) ? value2(prev) : value2;
+    if (props().debug) {
+      console.log(`[bindable > ${props().debug}] setValue`, { next, prev });
+    }
+    if (!controlled) setValue(next);
+    if (!eq(next, prev)) {
+      (_b = (_a = props()).onChange) == null ? void 0 : _b.call(_a, next, prev);
+    }
+  };
+  function get() {
+    return controlled ? props().value : value;
+  }
+  return {
+    initial: initialValue,
+    ref: valueRef,
+    get,
+    set(value2) {
+      const exec = props().sync ? reactDom.flushSync : identity;
+      exec(() => setFn(value2));
+    },
+    invoke(nextValue, prevValue2) {
+      var _a, _b;
+      (_b = (_a = props()).onChange) == null ? void 0 : _b.call(_a, nextValue, prevValue2);
+    },
+    hash(value2) {
+      var _a, _b;
+      return ((_b = (_a = props()).hash) == null ? void 0 : _b.call(_a, value2)) ?? String(value2);
+    }
+  };
+}
+function useRefs(refs) {
+  const ref = React.useRef(refs);
+  return {
+    get(key) {
+      return ref.current[key];
+    },
+    set(key, value) {
+      ref.current[key] = value;
+    }
+  };
+}
+var useTrack = (deps, effect) => {
+  const render = React.useRef(false);
+  const called = React.useRef(false);
+  React.useEffect(() => {
+    const mounted = render.current;
+    const run = mounted && called.current;
+    if (run) return effect();
+    called.current = true;
+  }, [...(deps ?? []).map((d) => typeof d === "function" ? d() : d)]);
+  React.useEffect(() => {
+    render.current = true;
+    return () => {
+      render.current = false;
+    };
+  }, []);
+};
+function useMachine(machine2, userProps = {}) {
+  var _a, _b, _c, _d;
+  const scope = React.useMemo(() => {
+    const { id, ids, getRootNode } = userProps;
+    return createScope({ id, ids, getRootNode });
+  }, [userProps]);
+  const debug = (...args) => {
+    if (machine2.debug) console.log(...args);
+  };
+  const props = ((_a = machine2.props) == null ? void 0 : _a.call(machine2, { props: compact(userProps), scope })) ?? userProps;
+  const prop = useProp(props);
+  const context2 = (_b = machine2.context) == null ? void 0 : _b.call(machine2, {
+    prop,
+    bindable: useBindable,
+    scope,
+    flush,
+    getContext() {
+      return ctx;
+    },
+    getComputed() {
+      return computed;
+    }
+  });
+  const contextRef = useLiveRef(context2);
+  const ctx = {
+    get(key) {
+      var _a2;
+      return (_a2 = contextRef.current) == null ? void 0 : _a2[key].ref.current;
+    },
+    set(key, value) {
+      var _a2;
+      (_a2 = contextRef.current) == null ? void 0 : _a2[key].set(value);
+    },
+    initial(key) {
+      var _a2;
+      return (_a2 = contextRef.current) == null ? void 0 : _a2[key].initial;
+    },
+    hash(key) {
+      var _a2, _b2;
+      const current = (_a2 = contextRef.current) == null ? void 0 : _a2[key].get();
+      return (_b2 = contextRef.current) == null ? void 0 : _b2[key].hash(current);
+    }
+  };
+  const effects = React.useRef(/* @__PURE__ */ new Map());
+  const transitionRef = React.useRef(null);
+  const previousEventRef = React.useRef(null);
+  const eventRef = React.useRef({ type: "" });
+  const getEvent = () => ({
+    ...eventRef.current,
+    current() {
+      return eventRef.current;
+    },
+    previous() {
+      return previousEventRef.current;
+    }
+  });
+  const getState = () => ({
+    ...state,
+    matches(...values) {
+      return values.includes(state.ref.current);
+    },
+    hasTag(tag) {
+      var _a2, _b2;
+      return !!((_b2 = (_a2 = machine2.states[state.ref.current]) == null ? void 0 : _a2.tags) == null ? void 0 : _b2.includes(tag));
+    }
+  });
+  const refs = useRefs(((_c = machine2.refs) == null ? void 0 : _c.call(machine2, { prop, context: ctx })) ?? {});
+  const getParams = () => ({
+    state: getState(),
+    context: ctx,
+    event: getEvent(),
+    prop,
+    send,
+    action,
+    guard,
+    track: useTrack,
+    refs,
+    computed,
+    flush,
+    scope,
+    choose
+  });
+  const action = (keys) => {
+    const strs = isFunction(keys) ? keys(getParams()) : keys;
+    if (!strs) return;
+    const fns2 = strs.map((s) => {
+      var _a2, _b2;
+      const fn = (_b2 = (_a2 = machine2.implementations) == null ? void 0 : _a2.actions) == null ? void 0 : _b2[s];
+      if (!fn) warn(`[zag-js] No implementation found for action "${JSON.stringify(s)}"`);
+      return fn;
+    });
+    for (const fn of fns2) {
+      fn == null ? void 0 : fn(getParams());
+    }
+  };
+  const guard = (str) => {
+    var _a2, _b2;
+    if (isFunction(str)) return str(getParams());
+    return (_b2 = (_a2 = machine2.implementations) == null ? void 0 : _a2.guards) == null ? void 0 : _b2[str](getParams());
+  };
+  const effect = (keys) => {
+    const strs = isFunction(keys) ? keys(getParams()) : keys;
+    if (!strs) return;
+    const fns2 = strs.map((s) => {
+      var _a2, _b2;
+      const fn = (_b2 = (_a2 = machine2.implementations) == null ? void 0 : _a2.effects) == null ? void 0 : _b2[s];
+      if (!fn) warn(`[zag-js] No implementation found for effect "${JSON.stringify(s)}"`);
+      return fn;
+    });
+    const cleanups2 = [];
+    for (const fn of fns2) {
+      const cleanup = fn == null ? void 0 : fn(getParams());
+      if (cleanup) cleanups2.push(cleanup);
+    }
+    return () => cleanups2.forEach((fn) => fn == null ? void 0 : fn());
+  };
+  const choose = (transitions) => {
+    return toArray(transitions).find((t) => {
+      let result = !t.guard;
+      if (isString(t.guard)) result = !!guard(t.guard);
+      else if (isFunction(t.guard)) result = t.guard(getParams());
+      return result;
+    });
+  };
+  const computed = (key) => {
+    ensure(machine2.computed, `[zag-js] No computed object found on machine`);
+    const fn = machine2.computed[key];
+    return fn({
+      context: ctx,
+      event: getEvent(),
+      prop,
+      refs,
+      scope,
+      computed
+    });
+  };
+  const state = useBindable(() => ({
+    defaultValue: machine2.initialState({ prop }),
+    onChange(nextState, prevState) {
+      var _a2, _b2, _c2, _d2;
+      if (prevState) {
+        const exitEffects = effects.current.get(prevState);
+        exitEffects == null ? void 0 : exitEffects();
+        effects.current.delete(prevState);
+      }
+      if (prevState) {
+        action((_a2 = machine2.states[prevState]) == null ? void 0 : _a2.exit);
+      }
+      action((_b2 = transitionRef.current) == null ? void 0 : _b2.actions);
+      const cleanup = effect((_c2 = machine2.states[nextState]) == null ? void 0 : _c2.effects);
+      if (cleanup) effects.current.set(nextState, cleanup);
+      if (prevState === "__init__") {
+        action(machine2.entry);
+        const cleanup2 = effect(machine2.effects);
+        if (cleanup2) effects.current.set("__init__", cleanup2);
+      }
+      action((_d2 = machine2.states[nextState]) == null ? void 0 : _d2.entry);
+    }
+  }));
+  const hydratedStateRef = React.useRef(void 0);
+  useSafeLayoutEffect(() => {
+    queueMicrotask(() => {
+      const initialState = hydratedStateRef.current ?? state.initial;
+      state.invoke(initialState, "__init__");
+    });
+    const fns2 = effects.current;
+    return () => {
+      hydratedStateRef.current = state.ref.current;
+      fns2.forEach((fn) => fn == null ? void 0 : fn());
+      effects.current = /* @__PURE__ */ new Map();
+      transitionRef.current = null;
+      queueMicrotask(() => {
+        action(machine2.exit);
+      });
+    };
+  }, []);
+  const getCurrentState = () => {
+    if ("ref" in state) return state.ref.current;
+    return state.get();
+  };
+  const send = (event) => {
+    queueMicrotask(() => {
+      var _a2, _b2;
+      previousEventRef.current = eventRef.current;
+      eventRef.current = event;
+      debug("send", event);
+      let currentState = getCurrentState();
+      const transitions = (
+        // @ts-ignore
+        ((_a2 = machine2.states[currentState].on) == null ? void 0 : _a2[event.type]) ?? // @ts-ignore
+        ((_b2 = machine2.on) == null ? void 0 : _b2[event.type])
+      );
+      const transition = choose(transitions);
+      if (!transition) return;
+      transitionRef.current = transition;
+      const target = transition.target ?? currentState;
+      debug("transition", transition);
+      const changed = target !== currentState;
+      if (changed) {
+        reactDom.flushSync(() => state.set(target));
+      } else if (transition.reenter && !changed) {
+        state.invoke(currentState, currentState);
+      } else {
+        action(transition.actions ?? []);
+      }
+    });
+  };
+  (_d = machine2.watch) == null ? void 0 : _d.call(machine2, getParams());
+  return {
+    state: getState(),
+    send,
+    context: ctx,
+    prop,
+    scope,
+    refs,
+    computed,
+    event: getEvent()
+  };
+}
+function useLiveRef(value) {
+  const ref = React.useRef(value);
+  ref.current = value;
+  return ref;
+}
+function useProp(value) {
+  const ref = useLiveRef(value);
+  return function get(key) {
+    return ref.current[key];
+  };
+}
+function flush(fn) {
+  queueMicrotask(() => {
+    reactDom.flushSync(() => fn());
+  });
+}
+var normalizeProps = createNormalizer((v2) => v2);
+function composeRefs(...refs) {
+  return (node) => {
+    const cleanUps = [];
+    for (const ref of refs) {
+      if (typeof ref === "function") {
+        const cb = ref(node);
+        if (typeof cb === "function") {
+          cleanUps.push(cb);
+        }
+      } else if (ref) {
+        ref.current = node;
+      }
+    }
+    if (cleanUps.length) {
+      return () => {
+        for (const cleanUp of cleanUps) {
+          cleanUp();
+        }
+      };
+    }
+  };
+}
+function getRef(element) {
+  var _a, _b;
+  let getter = (_a = Object.getOwnPropertyDescriptor(element.props, "ref")) == null ? void 0 : _a.get;
+  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.ref;
+  }
+  getter = (_b = Object.getOwnPropertyDescriptor(element, "ref")) == null ? void 0 : _b.get;
+  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.props.ref;
+  }
+  return element.props.ref || element.ref;
+}
+const withAsChild = (Component) => {
+  const Comp = React.memo(
+    React.forwardRef((props, ref) => {
+      const { asChild, children, ...restProps } = props;
+      if (!asChild) {
+        return React.createElement(Component, { ...restProps, ref }, children);
+      }
+      const onlyChild = React.Children.only(children);
+      if (!React.isValidElement(onlyChild)) {
+        return null;
+      }
+      const childRef = getRef(onlyChild);
+      return React.cloneElement(onlyChild, {
+        ...mergeProps(restProps, onlyChild.props),
+        ref: ref ? composeRefs(ref, childRef) : childRef
+      });
+    })
+  );
+  Comp.displayName = Component.displayName || Component.name;
+  return Comp;
+};
+const jsxFactory = () => {
+  const cache = /* @__PURE__ */ new Map();
+  return new Proxy(withAsChild, {
+    apply(_target, _thisArg, argArray) {
+      return withAsChild(argArray[0]);
+    },
+    get(_, element) {
+      const asElement = element;
+      if (!cache.has(asElement)) {
+        cache.set(asElement, withAsChild(asElement));
+      }
+      return cache.get(asElement);
+    }
+  });
+};
+const ark = jsxFactory();
+const createSplitProps = () => (props, keys) => keys.reduce(
+  (previousValue, currentValue) => {
+    const [target, source] = previousValue;
+    const key = currentValue;
+    if (source[key] !== void 0) {
+      target[key] = source[key];
+    }
+    delete source[key];
+    return [target, source];
+  },
+  [{}, { ...props }]
+);
+var createAnatomy = (name, parts2 = []) => ({
+  parts: (...values) => {
+    if (isEmpty(parts2)) {
+      return createAnatomy(name, values);
+    }
+    throw new Error("createAnatomy().parts(...) should only be called once. Did you mean to use .extendWith(...) ?");
+  },
+  extendWith: (...values) => createAnatomy(name, [...parts2, ...values]),
+  rename: (newName) => createAnatomy(newName, parts2),
+  keys: () => parts2,
+  build: () => [...new Set(parts2)].reduce(
+    (prev, part) => Object.assign(prev, {
+      [part]: {
+        selector: [
+          `&[data-scope="${toKebabCase(name)}"][data-part="${toKebabCase(part)}"]`,
+          `& [data-scope="${toKebabCase(name)}"][data-part="${toKebabCase(part)}"]`
+        ].join(", "),
+        attrs: { "data-scope": toKebabCase(name), "data-part": toKebabCase(part) }
+      }
+    }),
+    {}
+  )
+});
+var toKebabCase = (value) => value.replace(/([A-Z])([A-Z])/g, "$1-$2").replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+var isEmpty = (v2) => v2.length === 0;
+const [EnvironmentContextProvider, useEnvironmentContext] = createContext({
+  name: "EnvironmentContext",
+  hookName: "useEnvironmentContext",
+  providerName: "<EnvironmentProvider />",
+  strict: false,
+  defaultValue: {
+    getRootNode: () => document,
+    getDocument: () => document,
+    getWindow: () => window
+  }
+});
+const [LocaleContextProvider, useLocaleContext] = createContext({
+  name: "LocaleContext",
+  hookName: "useLocaleContext",
+  providerName: "<LocaleProvider />",
+  strict: false,
+  defaultValue: { dir: "ltr", locale: "en-US" }
+});
+function getWindowFrames(win) {
+  const frames = {
+    each(cb) {
+      var _a;
+      for (let i = 0; i < ((_a = win.frames) == null ? void 0 : _a.length); i += 1) {
+        const frame = win.frames[i];
+        if (frame) cb(frame);
+      }
+    },
+    addEventListener(event, listener, options) {
+      frames.each((frame) => {
+        try {
+          frame.document.addEventListener(event, listener, options);
+        } catch {
+        }
+      });
+      return () => {
+        try {
+          frames.removeEventListener(event, listener, options);
+        } catch {
+        }
+      };
+    },
+    removeEventListener(event, listener, options) {
+      frames.each((frame) => {
+        try {
+          frame.document.removeEventListener(event, listener, options);
+        } catch {
+        }
+      });
+    }
+  };
+  return frames;
+}
+function getParentWindow(win) {
+  const parent = win.frameElement != null ? win.parent : null;
+  return {
+    addEventListener: (event, listener, options) => {
+      try {
+        parent == null ? void 0 : parent.addEventListener(event, listener, options);
+      } catch {
+      }
+      return () => {
+        try {
+          parent == null ? void 0 : parent.removeEventListener(event, listener, options);
+        } catch {
+        }
+      };
+    },
+    removeEventListener: (event, listener, options) => {
+      try {
+        parent == null ? void 0 : parent.removeEventListener(event, listener, options);
+      } catch {
+      }
+    }
+  };
+}
+var POINTER_OUTSIDE_EVENT = "pointerdown.outside";
+var FOCUS_OUTSIDE_EVENT = "focus.outside";
+function isComposedPathFocusable(composedPath) {
+  for (const node of composedPath) {
+    if (isHTMLElement(node) && isFocusable(node)) return true;
+  }
+  return false;
+}
+var isPointerEvent = (event) => "clientY" in event;
+function isEventPointWithin(node, event) {
+  if (!isPointerEvent(event) || !node) return false;
+  const rect = node.getBoundingClientRect();
+  if (rect.width === 0 || rect.height === 0) return false;
+  return rect.top <= event.clientY && event.clientY <= rect.top + rect.height && rect.left <= event.clientX && event.clientX <= rect.left + rect.width;
+}
+function isPointInRect(rect, point) {
+  return rect.y <= point.y && point.y <= rect.y + rect.height && rect.x <= point.x && point.x <= rect.x + rect.width;
+}
+function isEventWithinScrollbar(event, ancestor) {
+  if (!ancestor || !isPointerEvent(event)) return false;
+  const isScrollableY = ancestor.scrollHeight > ancestor.clientHeight;
+  const onScrollbarY = isScrollableY && event.clientX > ancestor.offsetLeft + ancestor.clientWidth;
+  const isScrollableX = ancestor.scrollWidth > ancestor.clientWidth;
+  const onScrollbarX = isScrollableX && event.clientY > ancestor.offsetTop + ancestor.clientHeight;
+  const rect = {
+    x: ancestor.offsetLeft,
+    y: ancestor.offsetTop,
+    width: ancestor.clientWidth + (isScrollableY ? 16 : 0),
+    height: ancestor.clientHeight + (isScrollableX ? 16 : 0)
+  };
+  const point = {
+    x: event.clientX,
+    y: event.clientY
+  };
+  if (!isPointInRect(rect, point)) return false;
+  return onScrollbarY || onScrollbarX;
+}
+function trackInteractOutsideImpl(node, options) {
+  const { exclude, onFocusOutside, onPointerDownOutside, onInteractOutside, defer } = options;
+  if (!node) return;
+  const doc = getDocument(node);
+  const win = getWindow(node);
+  const frames = getWindowFrames(win);
+  const parentWin = getParentWindow(win);
+  function isEventOutside(event) {
+    const target = getEventTarget(event);
+    if (!isHTMLElement(target)) return false;
+    if (!target.isConnected) return false;
+    if (contains(node, target)) return false;
+    if (isEventPointWithin(node, event)) return false;
+    const triggerEl = doc.querySelector(`[aria-controls="${node.id}"]`);
+    if (triggerEl) {
+      const triggerAncestor = getNearestOverflowAncestor(triggerEl);
+      if (isEventWithinScrollbar(event, triggerAncestor)) return false;
+    }
+    const nodeAncestor = getNearestOverflowAncestor(node);
+    if (isEventWithinScrollbar(event, nodeAncestor)) return false;
+    return !(exclude == null ? void 0 : exclude(target));
+  }
+  const pointerdownCleanups = /* @__PURE__ */ new Set();
+  function onPointerDown(event) {
+    function handler() {
+      var _a;
+      const func = defer ? raf$1 : (v2) => v2();
+      const composedPath = ((_a = event.composedPath) == null ? void 0 : _a.call(event)) ?? [event.target];
+      func(() => {
+        if (!node || !isEventOutside(event)) return;
+        if (onPointerDownOutside || onInteractOutside) {
+          const handler2 = callAll(onPointerDownOutside, onInteractOutside);
+          node.addEventListener(POINTER_OUTSIDE_EVENT, handler2, { once: true });
+        }
+        fireCustomEvent(node, POINTER_OUTSIDE_EVENT, {
+          bubbles: false,
+          cancelable: true,
+          detail: {
+            originalEvent: event,
+            contextmenu: isContextMenuEvent(event),
+            focusable: isComposedPathFocusable(composedPath)
+          }
+        });
+      });
+    }
+    if (event.pointerType === "touch") {
+      pointerdownCleanups.forEach((fn) => fn());
+      pointerdownCleanups.add(addDomEvent(doc, "click", handler, { once: true }));
+      pointerdownCleanups.add(parentWin.addEventListener("click", handler, { once: true }));
+      pointerdownCleanups.add(frames.addEventListener("click", handler, { once: true }));
+    } else {
+      handler();
+    }
+  }
+  const cleanups2 = /* @__PURE__ */ new Set();
+  const timer = setTimeout(() => {
+    cleanups2.add(addDomEvent(doc, "pointerdown", onPointerDown, true));
+    cleanups2.add(parentWin.addEventListener("pointerdown", onPointerDown, true));
+    cleanups2.add(frames.addEventListener("pointerdown", onPointerDown, true));
+  }, 0);
+  function onFocusin(event) {
+    const func = defer ? raf$1 : (v2) => v2();
+    func(() => {
+      if (!node || !isEventOutside(event)) return;
+      if (onFocusOutside || onInteractOutside) {
+        const handler = callAll(onFocusOutside, onInteractOutside);
+        node.addEventListener(FOCUS_OUTSIDE_EVENT, handler, { once: true });
+      }
+      fireCustomEvent(node, FOCUS_OUTSIDE_EVENT, {
+        bubbles: false,
+        cancelable: true,
+        detail: {
+          originalEvent: event,
+          contextmenu: false,
+          focusable: isFocusable(getEventTarget(event))
+        }
+      });
+    });
+  }
+  cleanups2.add(addDomEvent(doc, "focusin", onFocusin, true));
+  cleanups2.add(parentWin.addEventListener("focusin", onFocusin, true));
+  cleanups2.add(frames.addEventListener("focusin", onFocusin, true));
+  return () => {
+    clearTimeout(timer);
+    pointerdownCleanups.forEach((fn) => fn());
+    cleanups2.forEach((fn) => fn());
+  };
+}
+function trackInteractOutside(nodeOrFn, options) {
+  const { defer } = options;
+  const func = defer ? raf$1 : (v2) => v2();
+  const cleanups2 = [];
+  cleanups2.push(
+    func(() => {
+      const node = typeof nodeOrFn === "function" ? nodeOrFn() : nodeOrFn;
+      cleanups2.push(trackInteractOutsideImpl(node, options));
+    })
+  );
+  return () => {
+    cleanups2.forEach((fn) => fn == null ? void 0 : fn());
+  };
+}
+function fireCustomEvent(el, type, init) {
+  const win = el.ownerDocument.defaultView || window;
+  const event = new win.CustomEvent(type, init);
+  return el.dispatchEvent(event);
+}
+function trackEscapeKeydown(node, fn) {
+  const handleKeyDown = (event) => {
+    if (event.key !== "Escape") return;
+    if (event.isComposing) return;
+    fn == null ? void 0 : fn(event);
+  };
+  return addDomEvent(getDocument(node), "keydown", handleKeyDown, { capture: true });
+}
+var layerStack = {
+  layers: [],
+  branches: [],
+  count() {
+    return this.layers.length;
+  },
+  pointerBlockingLayers() {
+    return this.layers.filter((layer) => layer.pointerBlocking);
+  },
+  topMostPointerBlockingLayer() {
+    return [...this.pointerBlockingLayers()].slice(-1)[0];
+  },
+  hasPointerBlockingLayer() {
+    return this.pointerBlockingLayers().length > 0;
+  },
+  isBelowPointerBlockingLayer(node) {
+    var _a;
+    const index = this.indexOf(node);
+    const highestBlockingIndex = this.topMostPointerBlockingLayer() ? this.indexOf((_a = this.topMostPointerBlockingLayer()) == null ? void 0 : _a.node) : -1;
+    return index < highestBlockingIndex;
+  },
+  isTopMost(node) {
+    const layer = this.layers[this.count() - 1];
+    return (layer == null ? void 0 : layer.node) === node;
+  },
+  getNestedLayers(node) {
+    return Array.from(this.layers).slice(this.indexOf(node) + 1);
+  },
+  isInNestedLayer(node, target) {
+    return this.getNestedLayers(node).some((layer) => contains(layer.node, target));
+  },
+  isInBranch(target) {
+    return Array.from(this.branches).some((branch) => contains(branch, target));
+  },
+  add(layer) {
+    const num = this.layers.push(layer);
+    layer.node.style.setProperty("--layer-index", `${num}`);
+  },
+  addBranch(node) {
+    this.branches.push(node);
+  },
+  remove(node) {
+    const index = this.indexOf(node);
+    if (index < 0) return;
+    if (index < this.count() - 1) {
+      const _layers = this.getNestedLayers(node);
+      _layers.forEach((layer) => layer.dismiss());
+    }
+    this.layers.splice(index, 1);
+    node.style.removeProperty("--layer-index");
+  },
+  removeBranch(node) {
+    const index = this.branches.indexOf(node);
+    if (index >= 0) this.branches.splice(index, 1);
+  },
+  indexOf(node) {
+    return this.layers.findIndex((layer) => layer.node === node);
+  },
+  dismiss(node) {
+    var _a;
+    (_a = this.layers[this.indexOf(node)]) == null ? void 0 : _a.dismiss();
+  },
+  clear() {
+    this.remove(this.layers[0].node);
+  }
+};
+var originalBodyPointerEvents;
+function assignPointerEventToLayers() {
+  layerStack.layers.forEach(({ node }) => {
+    node.style.pointerEvents = layerStack.isBelowPointerBlockingLayer(node) ? "none" : "auto";
+  });
+}
+function clearPointerEvent(node) {
+  node.style.pointerEvents = "";
+}
+function disablePointerEventsOutside(node, persistentElements) {
+  const doc = getDocument(node);
+  const cleanups2 = [];
+  if (layerStack.hasPointerBlockingLayer() && !doc.body.hasAttribute("data-inert")) {
+    originalBodyPointerEvents = document.body.style.pointerEvents;
+    queueMicrotask(() => {
+      doc.body.style.pointerEvents = "none";
+      doc.body.setAttribute("data-inert", "");
+    });
+  }
+  if (persistentElements) {
+    const persistedCleanup = waitForElements(persistentElements, (el) => {
+      cleanups2.push(setStyle(el, { pointerEvents: "auto" }));
+    });
+    cleanups2.push(persistedCleanup);
+  }
+  return () => {
+    if (layerStack.hasPointerBlockingLayer()) return;
+    queueMicrotask(() => {
+      doc.body.style.pointerEvents = originalBodyPointerEvents;
+      doc.body.removeAttribute("data-inert");
+      if (doc.body.style.length === 0) doc.body.removeAttribute("style");
+    });
+    cleanups2.forEach((fn) => fn());
+  };
+}
+function trackDismissableElementImpl(node, options) {
+  const { warnOnMissingNode = true } = options;
+  if (warnOnMissingNode && !node) {
+    warn("[@zag-js/dismissable] node is `null` or `undefined`");
+    return;
+  }
+  if (!node) {
+    return;
+  }
+  const { onDismiss, pointerBlocking, exclude: excludeContainers, debug } = options;
+  const layer = { dismiss: onDismiss, node, pointerBlocking };
+  layerStack.add(layer);
+  assignPointerEventToLayers();
+  function onPointerDownOutside(event) {
+    var _a, _b;
+    const target = getEventTarget(event.detail.originalEvent);
+    if (layerStack.isBelowPointerBlockingLayer(node) || layerStack.isInBranch(target)) return;
+    (_a = options.onPointerDownOutside) == null ? void 0 : _a.call(options, event);
+    (_b = options.onInteractOutside) == null ? void 0 : _b.call(options, event);
+    if (event.defaultPrevented) return;
+    if (debug) {
+      console.log("onPointerDownOutside:", event.detail.originalEvent);
+    }
+    onDismiss == null ? void 0 : onDismiss();
+  }
+  function onFocusOutside(event) {
+    var _a, _b;
+    const target = getEventTarget(event.detail.originalEvent);
+    if (layerStack.isInBranch(target)) return;
+    (_a = options.onFocusOutside) == null ? void 0 : _a.call(options, event);
+    (_b = options.onInteractOutside) == null ? void 0 : _b.call(options, event);
+    if (event.defaultPrevented) return;
+    if (debug) {
+      console.log("onFocusOutside:", event.detail.originalEvent);
+    }
+    onDismiss == null ? void 0 : onDismiss();
+  }
+  function onEscapeKeyDown(event) {
+    var _a;
+    if (!layerStack.isTopMost(node)) return;
+    (_a = options.onEscapeKeyDown) == null ? void 0 : _a.call(options, event);
+    if (!event.defaultPrevented && onDismiss) {
+      event.preventDefault();
+      onDismiss();
+    }
+  }
+  function exclude(target) {
+    var _a;
+    if (!node) return false;
+    const containers = typeof excludeContainers === "function" ? excludeContainers() : excludeContainers;
+    const _containers = Array.isArray(containers) ? containers : [containers];
+    const persistentElements = (_a = options.persistentElements) == null ? void 0 : _a.map((fn) => fn()).filter(isHTMLElement);
+    if (persistentElements) _containers.push(...persistentElements);
+    return _containers.some((node2) => contains(node2, target)) || layerStack.isInNestedLayer(node, target);
+  }
+  const cleanups2 = [
+    pointerBlocking ? disablePointerEventsOutside(node, options.persistentElements) : void 0,
+    trackEscapeKeydown(node, onEscapeKeyDown),
+    trackInteractOutside(node, { exclude, onFocusOutside, onPointerDownOutside, defer: options.defer })
+  ];
+  return () => {
+    layerStack.remove(node);
+    assignPointerEventToLayers();
+    clearPointerEvent(node);
+    cleanups2.forEach((fn) => fn == null ? void 0 : fn());
+  };
+}
+function trackDismissableElement(nodeOrFn, options) {
+  const { defer } = options;
+  const func = defer ? raf$1 : (v2) => v2();
+  const cleanups2 = [];
+  cleanups2.push(
+    func(() => {
+      const node = isFunction(nodeOrFn) ? nodeOrFn() : nodeOrFn;
+      cleanups2.push(trackDismissableElementImpl(node, options));
+    })
+  );
+  return () => {
+    cleanups2.forEach((fn) => fn == null ? void 0 : fn());
+  };
+}
+const [RenderStrategyPropsProvider, useRenderStrategyPropsContext] = createContext({
+  name: "RenderStrategyContext",
+  hookName: "useRenderStrategyContext",
+  providerName: "<RenderStrategyPropsProvider />"
+});
+const splitRenderStrategyProps = (props) => createSplitProps()(props, ["lazyMount", "unmountOnExit"]);
+function useEvent(callback, opts = {}) {
+  const { sync = false } = opts;
+  const callbackRef = useLatestRef(callback);
+  return React.useCallback(
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    (...args) => {
+      var _a;
+      if (sync) return queueMicrotask(() => {
+        var _a2;
+        return (_a2 = callbackRef.current) == null ? void 0 : _a2.call(callbackRef, ...args);
+      });
+      return (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, ...args);
+    },
+    [sync, callbackRef]
+  );
+}
+function useLatestRef(value) {
+  const ref = React.useRef(value);
+  ref.current = value;
+  return ref;
+}
+const [PresenceProvider, usePresenceContext] = createContext({
+  name: "PresenceContext",
+  hookName: "usePresenceContext",
+  providerName: "<PresenceProvider />"
+});
+const splitPresenceProps = (props) => createSplitProps()(props, ["immediate", "lazyMount", "onExitComplete", "present", "unmountOnExit"]);
+function connect$1(service, _normalize) {
+  const { state, send, context: context2 } = service;
+  const present = state.matches("mounted", "unmountSuspended");
+  return {
+    skip: !context2.get("initial"),
+    present,
+    setNode(node) {
+      if (!node) return;
+      send({ type: "NODE.SET", node });
+    },
+    unmount() {
+      send({ type: "UNMOUNT" });
+    }
+  };
+}
+var machine$1 = createMachine({
+  props({ props: props2 }) {
+    return { ...props2, present: !!props2.present };
+  },
+  initialState({ prop }) {
+    return prop("present") ? "mounted" : "unmounted";
+  },
+  refs() {
+    return {
+      node: null,
+      styles: null
+    };
+  },
+  context({ bindable }) {
+    return {
+      unmountAnimationName: bindable(() => ({ defaultValue: null })),
+      prevAnimationName: bindable(() => ({ defaultValue: null })),
+      present: bindable(() => ({ defaultValue: false })),
+      initial: bindable(() => ({
+        sync: true,
+        defaultValue: false
+      }))
+    };
+  },
+  exit: ["clearInitial", "cleanupNode"],
+  watch({ track, action, prop }) {
+    track([() => prop("present")], () => {
+      action(["setInitial", "syncPresence"]);
+    });
+  },
+  on: {
+    "NODE.SET": {
+      actions: ["setNode", "setStyles"]
+    }
+  },
+  states: {
+    mounted: {
+      on: {
+        UNMOUNT: {
+          target: "unmounted",
+          actions: ["clearPrevAnimationName", "invokeOnExitComplete"]
+        },
+        "UNMOUNT.SUSPEND": {
+          target: "unmountSuspended"
+        }
+      }
+    },
+    unmountSuspended: {
+      effects: ["trackAnimationEvents"],
+      on: {
+        MOUNT: {
+          target: "mounted",
+          actions: ["setPrevAnimationName"]
+        },
+        UNMOUNT: {
+          target: "unmounted",
+          actions: ["clearPrevAnimationName", "invokeOnExitComplete"]
+        }
+      }
+    },
+    unmounted: {
+      on: {
+        MOUNT: {
+          target: "mounted",
+          actions: ["setPrevAnimationName"]
+        }
+      }
+    }
+  },
+  implementations: {
+    actions: {
+      setInitial: ({ context: context2 }) => {
+        if (context2.get("initial")) return;
+        queueMicrotask(() => {
+          context2.set("initial", true);
+        });
+      },
+      clearInitial: ({ context: context2 }) => {
+        context2.set("initial", false);
+      },
+      cleanupNode: ({ refs }) => {
+        refs.set("node", null);
+        refs.set("styles", null);
+      },
+      invokeOnExitComplete: ({ prop }) => {
+        var _a;
+        (_a = prop("onExitComplete")) == null ? void 0 : _a();
+      },
+      setNode: ({ refs, event }) => {
+        refs.set("node", event.node);
+      },
+      setStyles: ({ refs, event }) => {
+        refs.set("styles", getComputedStyle(event.node));
+      },
+      syncPresence: ({ context: context2, refs, send, prop }) => {
+        const presentProp = prop("present");
+        if (presentProp) {
+          return send({ type: "MOUNT", src: "presence.changed" });
+        }
+        const node = refs.get("node");
+        if (!presentProp && (node == null ? void 0 : node.ownerDocument.visibilityState) === "hidden") {
+          return send({ type: "UNMOUNT", src: "visibilitychange" });
+        }
+        raf$1(() => {
+          var _a, _b;
+          const animationName = getAnimationName(refs.get("styles"));
+          context2.set("unmountAnimationName", animationName);
+          if (animationName === "none" || animationName === context2.get("prevAnimationName") || ((_a = refs.get("styles")) == null ? void 0 : _a.display) === "none" || ((_b = refs.get("styles")) == null ? void 0 : _b.animationDuration) === "0s") {
+            send({ type: "UNMOUNT", src: "presence.changed" });
+          } else {
+            send({ type: "UNMOUNT.SUSPEND" });
+          }
+        });
+      },
+      setPrevAnimationName: ({ context: context2, refs }) => {
+        raf$1(() => {
+          context2.set("prevAnimationName", getAnimationName(refs.get("styles")));
+        });
+      },
+      clearPrevAnimationName: ({ context: context2 }) => {
+        context2.set("prevAnimationName", null);
+      }
+    },
+    effects: {
+      trackAnimationEvents: ({ context: context2, refs, send }) => {
+        const node = refs.get("node");
+        if (!node) return;
+        const onStart = (event) => {
+          var _a, _b;
+          const target = ((_b = (_a = event.composedPath) == null ? void 0 : _a.call(event)) == null ? void 0 : _b[0]) ?? event.target;
+          if (target === node) {
+            context2.set("prevAnimationName", getAnimationName(refs.get("styles")));
+          }
+        };
+        const onEnd = (event) => {
+          const animationName = getAnimationName(refs.get("styles"));
+          const target = getEventTarget(event);
+          if (target === node && animationName === context2.get("unmountAnimationName")) {
+            send({ type: "UNMOUNT", src: "animationend" });
+          }
+        };
+        node.addEventListener("animationstart", onStart);
+        node.addEventListener("animationcancel", onEnd);
+        node.addEventListener("animationend", onEnd);
+        const cleanupStyles = setStyle(node, { animationFillMode: "forwards" });
+        return () => {
+          node.removeEventListener("animationstart", onStart);
+          node.removeEventListener("animationcancel", onEnd);
+          node.removeEventListener("animationend", onEnd);
+          nextTick(() => cleanupStyles());
+        };
+      }
+    }
+  }
+});
+function getAnimationName(styles) {
+  return (styles == null ? void 0 : styles.animationName) || "none";
+}
+createProps()(["onExitComplete", "present", "immediate"]);
+const usePresence = (props = {}) => {
+  const { lazyMount, unmountOnExit, present, ...rest } = props;
+  const wasEverPresent = React.useRef(false);
+  const machineProps = {
+    ...rest,
+    present,
+    onExitComplete: useEvent(props.onExitComplete)
+  };
+  const service = useMachine(machine$1, machineProps);
+  const api = connect$1(service);
+  if (api.present) {
+    wasEverPresent.current = true;
+  }
+  const unmounted = !api.present && !wasEverPresent.current && lazyMount || unmountOnExit && !api.present && wasEverPresent.current;
+  const getPresenceProps = () => ({
+    "data-state": present ? "open" : "closed",
+    hidden: !api.present
+  });
+  return {
+    ref: api.setNode,
+    getPresenceProps,
+    present: api.present,
+    unmounted
+  };
+};
+var counterMap = /* @__PURE__ */ new WeakMap();
+var uncontrolledNodes = /* @__PURE__ */ new WeakMap();
+var markerMap = {};
+var lockCount = 0;
+var unwrapHost = (node) => node && (node.host || unwrapHost(node.parentNode));
+var correctTargets = (parent, targets) => targets.map((target) => {
+  if (parent.contains(target)) return target;
+  const correctedTarget = unwrapHost(target);
+  if (correctedTarget && parent.contains(correctedTarget)) {
+    return correctedTarget;
+  }
+  console.error("[zag-js > ariaHidden] target", target, "in not contained inside", parent, ". Doing nothing");
+  return null;
+}).filter((x) => Boolean(x));
+var isIgnoredNode = (node) => {
+  if (node.localName === "next-route-announcer") return true;
+  if (node.localName === "script") return true;
+  if (node.hasAttribute("aria-live")) return true;
+  return node.matches("[data-live-announcer]");
+};
+var walkTreeOutside = (originalTarget, props) => {
+  const { parentNode, markerName, controlAttribute } = props;
+  const targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
+  markerMap[markerName] || (markerMap[markerName] = /* @__PURE__ */ new WeakMap());
+  const markerCounter = markerMap[markerName];
+  const hiddenNodes = [];
+  const elementsToKeep = /* @__PURE__ */ new Set();
+  const elementsToStop = new Set(targets);
+  const keep = (el) => {
+    if (!el || elementsToKeep.has(el)) return;
+    elementsToKeep.add(el);
+    keep(el.parentNode);
+  };
+  targets.forEach(keep);
+  const deep = (parent) => {
+    if (!parent || elementsToStop.has(parent)) {
+      return;
+    }
+    Array.prototype.forEach.call(parent.children, (node) => {
+      if (elementsToKeep.has(node)) {
+        deep(node);
+      } else {
+        try {
+          if (isIgnoredNode(node)) return;
+          const attr = node.getAttribute(controlAttribute);
+          const alreadyHidden = attr === "true";
+          const counterValue = (counterMap.get(node) || 0) + 1;
+          const 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, "");
+          }
+          if (!alreadyHidden) {
+            node.setAttribute(controlAttribute, "true");
+          }
+        } catch (e) {
+          console.error("[zag-js > ariaHidden] cannot operate on ", node, e);
+        }
+      }
+    });
+  };
+  deep(parentNode);
+  elementsToKeep.clear();
+  lockCount++;
+  return () => {
+    hiddenNodes.forEach((node) => {
+      const counterValue = counterMap.get(node) - 1;
+      const 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 getParentNode = (originalTarget) => {
+  const target = Array.isArray(originalTarget) ? originalTarget[0] : originalTarget;
+  return target.ownerDocument.body;
+};
+var hideOthers = (originalTarget, parentNode = getParentNode(originalTarget), markerName = "data-aria-hidden") => {
+  if (!parentNode) return;
+  return walkTreeOutside(originalTarget, {
+    parentNode,
+    markerName,
+    controlAttribute: "aria-hidden"
+  });
+};
+var raf = (fn) => {
+  const frameId = requestAnimationFrame(() => fn());
+  return () => cancelAnimationFrame(frameId);
+};
+function ariaHidden(targetsOrFn, options = {}) {
+  const { defer = true } = options;
+  const func = defer ? raf : (v2) => v2();
+  const cleanups2 = [];
+  cleanups2.push(
+    func(() => {
+      const targets = typeof targetsOrFn === "function" ? targetsOrFn() : targetsOrFn;
+      const elements = targets.filter(Boolean);
+      if (elements.length === 0) return;
+      cleanups2.push(hideOthers(elements));
+    })
+  );
+  return () => {
+    cleanups2.forEach((fn) => fn == null ? void 0 : fn());
+  };
+}
+const [DialogProvider, useDialogContext] = createContext({
+  name: "DialogContext",
+  hookName: "useDialogContext",
+  providerName: "<DialogProvider />"
+});
+const DialogBackdrop = React.forwardRef((props, ref) => {
+  const dialog = useDialogContext();
+  const renderStrategyProps = useRenderStrategyPropsContext();
+  const presence = usePresence({ ...renderStrategyProps, present: dialog.open });
+  const mergedProps = mergeProps(dialog.getBackdropProps(), presence.getPresenceProps(), props);
+  if (presence.unmounted) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(ark.div, { ...mergedProps, ref: composeRefs(presence.ref, ref) });
+});
+DialogBackdrop.displayName = "DialogBackdrop";
+const DialogContent = React.forwardRef((props, ref) => {
+  const dialog = useDialogContext();
+  const presence = usePresenceContext();
+  const mergedProps = mergeProps(dialog.getContentProps(), presence.getPresenceProps(), props);
+  if (presence.unmounted) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(ark.div, { ...mergedProps, ref: composeRefs(presence.ref, ref) });
+});
+DialogContent.displayName = "DialogContent";
+const DialogDescription = React.forwardRef((props, ref) => {
+  const dialog = useDialogContext();
+  const mergedProps = mergeProps(dialog.getDescriptionProps(), props);
+  return /* @__PURE__ */ jsxRuntime.jsx(ark.div, { ...mergedProps, ref });
+});
+DialogDescription.displayName = "DialogDescription";
+const DialogPositioner = React.forwardRef((props, ref) => {
+  const dialog = useDialogContext();
+  const mergedProps = mergeProps(dialog.getPositionerProps(), props);
+  const presence = usePresenceContext();
+  if (presence.unmounted) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(ark.div, { ...mergedProps, ref });
+});
+DialogPositioner.displayName = "DialogPositioner";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var activeFocusTraps = {
+  activateTrap(trapStack, trap) {
+    if (trapStack.length > 0) {
+      const activeTrap = trapStack[trapStack.length - 1];
+      if (activeTrap !== trap) {
+        activeTrap.pause();
+      }
+    }
+    const trapIndex = trapStack.indexOf(trap);
+    if (trapIndex === -1) {
+      trapStack.push(trap);
+    } else {
+      trapStack.splice(trapIndex, 1);
+      trapStack.push(trap);
+    }
+  },
+  deactivateTrap(trapStack, trap) {
+    const trapIndex = trapStack.indexOf(trap);
+    if (trapIndex !== -1) {
+      trapStack.splice(trapIndex, 1);
+    }
+    if (trapStack.length > 0) {
+      trapStack[trapStack.length - 1].unpause();
+    }
+  }
+};
+var sharedTrapStack = [];
+var FocusTrap = class {
+  constructor(elements, options) {
+    __publicField(this, "trapStack");
+    __publicField(this, "config");
+    __publicField(this, "doc");
+    __publicField(this, "state", {
+      containers: [],
+      containerGroups: [],
+      tabbableGroups: [],
+      nodeFocusedBeforeActivation: null,
+      mostRecentlyFocusedNode: null,
+      active: false,
+      paused: false,
+      delayInitialFocusTimer: void 0,
+      recentNavEvent: void 0
+    });
+    __publicField(this, "listenerCleanups", []);
+    __publicField(this, "handleFocus", (event) => {
+      const target = getEventTarget(event);
+      const targetContained = this.findContainerIndex(target, event) >= 0;
+      if (targetContained || isDocument(target)) {
+        if (targetContained) {
+          this.state.mostRecentlyFocusedNode = target;
+        }
+      } else {
+        event.stopImmediatePropagation();
+        let nextNode;
+        let navAcrossContainers = true;
+        if (this.state.mostRecentlyFocusedNode) {
+          if (getTabIndex(this.state.mostRecentlyFocusedNode) > 0) {
+            const mruContainerIdx = this.findContainerIndex(this.state.mostRecentlyFocusedNode);
+            const { tabbableNodes } = this.state.containerGroups[mruContainerIdx];
+            if (tabbableNodes.length > 0) {
+              const mruTabIdx = tabbableNodes.findIndex((node) => node === this.state.mostRecentlyFocusedNode);
+              if (mruTabIdx >= 0) {
+                if (this.config.isKeyForward(this.state.recentNavEvent)) {
+                  if (mruTabIdx + 1 < tabbableNodes.length) {
+                    nextNode = tabbableNodes[mruTabIdx + 1];
+                    navAcrossContainers = false;
+                  }
+                } else {
+                  if (mruTabIdx - 1 >= 0) {
+                    nextNode = tabbableNodes[mruTabIdx - 1];
+                    navAcrossContainers = false;
+                  }
+                }
+              }
+            }
+          } else {
+            if (!this.state.containerGroups.some((g2) => g2.tabbableNodes.some((n) => getTabIndex(n) > 0))) {
+              navAcrossContainers = false;
+            }
+          }
+        } else {
+          navAcrossContainers = false;
+        }
+        if (navAcrossContainers) {
+          nextNode = this.findNextNavNode({
+            // move FROM the MRU node, not event-related node (which will be the node that is
+            //  outside the trap causing the focus escape we're trying to fix)
+            target: this.state.mostRecentlyFocusedNode,
+            isBackward: this.config.isKeyBackward(this.state.recentNavEvent)
+          });
+        }
+        if (nextNode) {
+          this.tryFocus(nextNode);
+        } else {
+          this.tryFocus(this.state.mostRecentlyFocusedNode || this.getInitialFocusNode());
+        }
+      }
+      this.state.recentNavEvent = void 0;
+    });
+    __publicField(this, "handlePointerDown", (event) => {
+      const target = getEventTarget(event);
+      if (this.findContainerIndex(target, event) >= 0) {
+        return;
+      }
+      if (valueOrHandler(this.config.clickOutsideDeactivates, event)) {
+        this.deactivate({ returnFocus: this.config.returnFocusOnDeactivate });
+        return;
+      }
+      if (valueOrHandler(this.config.allowOutsideClick, event)) {
+        return;
+      }
+      event.preventDefault();
+    });
+    __publicField(this, "handleClick", (event) => {
+      const target = getEventTarget(event);
+      if (this.findContainerIndex(target, event) >= 0) {
+        return;
+      }
+      if (valueOrHandler(this.config.clickOutsideDeactivates, event)) {
+        return;
+      }
+      if (valueOrHandler(this.config.allowOutsideClick, event)) {
+        return;
+      }
+      event.preventDefault();
+      event.stopImmediatePropagation();
+    });
+    __publicField(this, "handleTabKey", (event) => {
+      if (this.config.isKeyForward(event) || this.config.isKeyBackward(event)) {
+        this.state.recentNavEvent = event;
+        const isBackward = this.config.isKeyBackward(event);
+        const destinationNode = this.findNextNavNode({ event, isBackward });
+        if (!destinationNode) return;
+        if (isTabEvent(event)) {
+          event.preventDefault();
+        }
+        this.tryFocus(destinationNode);
+      }
+    });
+    __publicField(this, "handleEscapeKey", (event) => {
+      if (isEscapeEvent(event) && valueOrHandler(this.config.escapeDeactivates, event) !== false) {
+        event.preventDefault();
+        this.deactivate();
+      }
+    });
+    __publicField(this, "_mutationObserver");
+    __publicField(this, "setupMutationObserver", () => {
+      const win = this.doc.defaultView || window;
+      this._mutationObserver = new win.MutationObserver((mutations) => {
+        const isFocusedNodeRemoved = mutations.some((mutation) => {
+          const removedNodes = Array.from(mutation.removedNodes);
+          return removedNodes.some((node) => node === this.state.mostRecentlyFocusedNode);
+        });
+        if (isFocusedNodeRemoved) {
+          this.tryFocus(this.getInitialFocusNode());
+        }
+      });
+    });
+    __publicField(this, "updateObservedNodes", () => {
+      var _a;
+      (_a = this._mutationObserver) == null ? void 0 : _a.disconnect();
+      if (this.state.active && !this.state.paused) {
+        this.state.containers.map((container) => {
+          var _a2;
+          (_a2 = this._mutationObserver) == null ? void 0 : _a2.observe(container, { subtree: true, childList: true });
+        });
+      }
+    });
+    __publicField(this, "getInitialFocusNode", () => {
+      let node = this.getNodeForOption("initialFocus", { hasFallback: true });
+      if (node === false) {
+        return false;
+      }
+      if (node === void 0 || node && !isFocusable(node)) {
+        if (this.findContainerIndex(this.doc.activeElement) >= 0) {
+          node = this.doc.activeElement;
+        } else {
+          const firstTabbableGroup = this.state.tabbableGroups[0];
+          const firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode;
+          node = firstTabbableNode || this.getNodeForOption("fallbackFocus");
+        }
+      } else if (node === null) {
+        node = this.getNodeForOption("fallbackFocus");
+      }
+      if (!node) {
+        throw new Error("Your focus-trap needs to have at least one focusable element");
+      }
+      if (!node.isConnected) {
+        node = this.getNodeForOption("fallbackFocus");
+      }
+      return node;
+    });
+    __publicField(this, "tryFocus", (node) => {
+      if (node === false) return;
+      if (node === getActiveElement(this.doc)) return;
+      if (!node || !node.focus) {
+        this.tryFocus(this.getInitialFocusNode());
+        return;
+      }
+      node.focus({ preventScroll: !!this.config.preventScroll });
+      this.state.mostRecentlyFocusedNode = node;
+      if (isSelectableInput(node)) {
+        node.select();
+      }
+    });
+    __publicField(this, "deactivate", (deactivateOptions) => {
+      if (!this.state.active) return this;
+      const options2 = {
+        onDeactivate: this.config.onDeactivate,
+        onPostDeactivate: this.config.onPostDeactivate,
+        checkCanReturnFocus: this.config.checkCanReturnFocus,
+        ...deactivateOptions
+      };
+      clearTimeout(this.state.delayInitialFocusTimer);
+      this.state.delayInitialFocusTimer = void 0;
+      this.removeListeners();
+      this.state.active = false;
+      this.state.paused = false;
+      this.updateObservedNodes();
+      activeFocusTraps.deactivateTrap(this.trapStack, this);
+      const onDeactivate = this.getOption(options2, "onDeactivate");
+      const onPostDeactivate = this.getOption(options2, "onPostDeactivate");
+      const checkCanReturnFocus = this.getOption(options2, "checkCanReturnFocus");
+      const returnFocus = this.getOption(options2, "returnFocus", "returnFocusOnDeactivate");
+      onDeactivate == null ? void 0 : onDeactivate();
+      const finishDeactivation = () => {
+        delay(() => {
+          if (returnFocus) {
+            const returnFocusNode = this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation);
+            this.tryFocus(returnFocusNode);
+          }
+          onPostDeactivate == null ? void 0 : onPostDeactivate();
+        });
+      };
+      if (returnFocus && checkCanReturnFocus) {
+        const returnFocusNode = this.getReturnFocusNode(this.state.nodeFocusedBeforeActivation);
+        checkCanReturnFocus(returnFocusNode).then(finishDeactivation, finishDeactivation);
+        return this;
+      }
+      finishDeactivation();
+      return this;
+    });
+    __publicField(this, "pause", (pauseOptions) => {
+      if (this.state.paused || !this.state.active) {
+        return this;
+      }
+      const onPause = this.getOption(pauseOptions, "onPause");
+      const onPostPause = this.getOption(pauseOptions, "onPostPause");
+      this.state.paused = true;
+      onPause == null ? void 0 : onPause();
+      this.removeListeners();
+      this.updateObservedNodes();
+      onPostPause == null ? void 0 : onPostPause();
+      return this;
+    });
+    __publicField(this, "unpause", (unpauseOptions) => {
+      if (!this.state.paused || !this.state.active) {
+        return this;
+      }
+      const onUnpause = this.getOption(unpauseOptions, "onUnpause");
+      const onPostUnpause = this.getOption(unpauseOptions, "onPostUnpause");
+      this.state.paused = false;
+      onUnpause == null ? void 0 : onUnpause();
+      this.updateTabbableNodes();
+      this.addListeners();
+      this.updateObservedNodes();
+      onPostUnpause == null ? void 0 : onPostUnpause();
+      return this;
+    });
+    __publicField(this, "updateContainerElements", (containerElements) => {
+      this.state.containers = Array.isArray(containerElements) ? containerElements.filter(Boolean) : [containerElements].filter(Boolean);
+      if (this.state.active) {
+        this.updateTabbableNodes();
+      }
+      this.updateObservedNodes();
+      return this;
+    });
+    __publicField(this, "getReturnFocusNode", (previousActiveElement) => {
+      const node = this.getNodeForOption("setReturnFocus", {
+        params: [previousActiveElement]
+      });
+      return node ? node : node === false ? false : previousActiveElement;
+    });
+    __publicField(this, "getOption", (configOverrideOptions, optionName, configOptionName) => {
+      return configOverrideOptions && configOverrideOptions[optionName] !== void 0 ? configOverrideOptions[optionName] : (
+        // @ts-expect-error
+        this.config[configOptionName || optionName]
+      );
+    });
+    __publicField(this, "getNodeForOption", (optionName, { hasFallback = false, params = [] } = {}) => {
+      let optionValue = this.config[optionName];
+      if (typeof optionValue === "function") optionValue = optionValue(...params);
+      if (optionValue === true) optionValue = void 0;
+      if (!optionValue) {
+        if (optionValue === void 0 || optionValue === false) {
+          return optionValue;
+        }
+        throw new Error(`\`${optionName}\` was specified but was not a node, or did not return a node`);
+      }
+      let node = optionValue;
+      if (typeof optionValue === "string") {
+        try {
+          node = this.doc.querySelector(optionValue);
+        } catch (err) {
+          throw new Error(`\`${optionName}\` appears to be an invalid selector; error="${err.message}"`);
+        }
+        if (!node) {
+          if (!hasFallback) {
+            throw new Error(`\`${optionName}\` as selector refers to no known node`);
+          }
+        }
+      }
+      return node;
+    });
+    __publicField(this, "findNextNavNode", (opts) => {
+      const { event, isBackward = false } = opts;
+      const target = opts.target || getEventTarget(event);
+      this.updateTabbableNodes();
+      let destinationNode = null;
+      if (this.state.tabbableGroups.length > 0) {
+        const containerIndex = this.findContainerIndex(target, event);
+        const containerGroup = containerIndex >= 0 ? this.state.containerGroups[containerIndex] : void 0;
+        if (containerIndex < 0) {
+          if (isBackward) {
+            destinationNode = this.state.tabbableGroups[this.state.tabbableGroups.length - 1].lastTabbableNode;
+          } else {
+            destinationNode = this.state.tabbableGroups[0].firstTabbableNode;
+          }
+        } else if (isBackward) {
+          let startOfGroupIndex = this.state.tabbableGroups.findIndex(
+            ({ firstTabbableNode }) => target === firstTabbableNode
+          );
+          if (startOfGroupIndex < 0 && ((containerGroup == null ? void 0 : containerGroup.container) === target || isFocusable(target) && !isTabbable(target) && !(containerGroup == null ? void 0 : containerGroup.nextTabbableNode(target, false)))) {
+            startOfGroupIndex = containerIndex;
+          }
+          if (startOfGroupIndex >= 0) {
+            const destinationGroupIndex = startOfGroupIndex === 0 ? this.state.tabbableGroups.length - 1 : startOfGroupIndex - 1;
+            const destinationGroup = this.state.tabbableGroups[destinationGroupIndex];
+            destinationNode = getTabIndex(target) >= 0 ? destinationGroup.lastTabbableNode : destinationGroup.lastDomTabbableNode;
+          } else if (!isTabEvent(event)) {
+            destinationNode = containerGroup == null ? void 0 : containerGroup.nextTabbableNode(target, false);
+          }
+        } else {
+          let lastOfGroupIndex = this.state.tabbableGroups.findIndex(
+            ({ lastTabbableNode }) => target === lastTabbableNode
+          );
+          if (lastOfGroupIndex < 0 && ((containerGroup == null ? void 0 : containerGroup.container) === target || isFocusable(target) && !isTabbable(target) && !(containerGroup == null ? void 0 : containerGroup.nextTabbableNode(target)))) {
+            lastOfGroupIndex = containerIndex;
+          }
+          if (lastOfGroupIndex >= 0) {
+            const destinationGroupIndex = lastOfGroupIndex === this.state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;
+            const destinationGroup = this.state.tabbableGroups[destinationGroupIndex];
+            destinationNode = getTabIndex(target) >= 0 ? destinationGroup.firstTabbableNode : destinationGroup.firstDomTabbableNode;
+          } else if (!isTabEvent(event)) {
+            destinationNode = containerGroup == null ? void 0 : containerGroup.nextTabbableNode(target);
+          }
+        }
+      } else {
+        destinationNode = this.getNodeForOption("fallbackFocus");
+      }
+      return destinationNode;
+    });
+    this.trapStack = options.trapStack || sharedTrapStack;
+    const config = {
+      returnFocusOnDeactivate: true,
+      escapeDeactivates: true,
+      delayInitialFocus: true,
+      isKeyForward(e) {
+        return isTabEvent(e) && !e.shiftKey;
+      },
+      isKeyBackward(e) {
+        return isTabEvent(e) && e.shiftKey;
+      },
+      ...options
+    };
+    this.doc = config.document || getDocument(Array.isArray(elements) ? elements[0] : elements);
+    this.config = config;
+    this.updateContainerElements(elements);
+    this.setupMutationObserver();
+  }
+  get active() {
+    return this.state.active;
+  }
+  get paused() {
+    return this.state.paused;
+  }
+  findContainerIndex(element, event) {
+    const composedPath = typeof (event == null ? void 0 : event.composedPath) === "function" ? event.composedPath() : void 0;
+    return this.state.containerGroups.findIndex(
+      ({ container, tabbableNodes }) => container.contains(element) || (composedPath == null ? void 0 : composedPath.includes(container)) || tabbableNodes.find((node) => node === element)
+    );
+  }
+  updateTabbableNodes() {
+    this.state.containerGroups = this.state.containers.map((container) => {
+      const tabbableNodes = getTabbables(container);
+      const focusableNodes = getFocusables(container);
+      const firstTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[0] : void 0;
+      const lastTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[tabbableNodes.length - 1] : void 0;
+      const firstDomTabbableNode = focusableNodes.find((node) => isTabbable(node));
+      const lastDomTabbableNode = focusableNodes.slice().reverse().find((node) => isTabbable(node));
+      const posTabIndexesFound = !!tabbableNodes.find((node) => getTabIndex(node) > 0);
+      function nextTabbableNode(node, forward = true) {
+        const nodeIdx = tabbableNodes.indexOf(node);
+        if (nodeIdx < 0) {
+          if (forward) {
+            return focusableNodes.slice(focusableNodes.indexOf(node) + 1).find((el) => isTabbable(el));
+          }
+          return focusableNodes.slice(0, focusableNodes.indexOf(node)).reverse().find((el) => isTabbable(el));
+        }
+        return tabbableNodes[nodeIdx + (forward ? 1 : -1)];
+      }
+      return {
+        container,
+        tabbableNodes,
+        focusableNodes,
+        posTabIndexesFound,
+        firstTabbableNode,
+        lastTabbableNode,
+        firstDomTabbableNode,
+        lastDomTabbableNode,
+        nextTabbableNode
+      };
+    });
+    this.state.tabbableGroups = this.state.containerGroups.filter((group) => group.tabbableNodes.length > 0);
+    if (this.state.tabbableGroups.length <= 0 && !this.getNodeForOption("fallbackFocus")) {
+      throw new Error(
+        "Your focus-trap must have at least one container with at least one tabbable node in it at all times"
+      );
+    }
+    if (this.state.containerGroups.find((g2) => g2.posTabIndexesFound) && this.state.containerGroups.length > 1) {
+      throw new Error(
+        "At least one node with a positive tabindex was found in one of your focus-trap's multiple containers. Positive tabindexes are only supported in single-container focus-traps."
+      );
+    }
+  }
+  addListeners() {
+    if (!this.state.active) return;
+    activeFocusTraps.activateTrap(this.trapStack, this);
+    this.state.delayInitialFocusTimer = this.config.delayInitialFocus ? delay(() => {
+      this.tryFocus(this.getInitialFocusNode());
+    }) : this.tryFocus(this.getInitialFocusNode());
+    this.listenerCleanups.push(
+      addDomEvent(this.doc, "focusin", this.handleFocus, true),
+      addDomEvent(this.doc, "mousedown", this.handlePointerDown, { capture: true, passive: false }),
+      addDomEvent(this.doc, "touchstart", this.handlePointerDown, { capture: true, passive: false }),
+      addDomEvent(this.doc, "click", this.handleClick, { capture: true, passive: false }),
+      addDomEvent(this.doc, "keydown", this.handleTabKey, { capture: true, passive: false }),
+      addDomEvent(this.doc, "keydown", this.handleEscapeKey)
+    );
+    return this;
+  }
+  removeListeners() {
+    if (!this.state.active) return;
+    this.listenerCleanups.forEach((cleanup) => cleanup());
+    this.listenerCleanups = [];
+    return this;
+  }
+  activate(activateOptions) {
+    if (this.state.active) {
+      return this;
+    }
+    const onActivate = this.getOption(activateOptions, "onActivate");
+    const onPostActivate = this.getOption(activateOptions, "onPostActivate");
+    const checkCanFocusTrap = this.getOption(activateOptions, "checkCanFocusTrap");
+    if (!checkCanFocusTrap) {
+      this.updateTabbableNodes();
+    }
+    this.state.active = true;
+    this.state.paused = false;
+    this.state.nodeFocusedBeforeActivation = this.doc.activeElement || null;
+    onActivate == null ? void 0 : onActivate();
+    const finishActivation = () => {
+      if (checkCanFocusTrap) {
+        this.updateTabbableNodes();
+      }
+      this.addListeners();
+      this.updateObservedNodes();
+      onPostActivate == null ? void 0 : onPostActivate();
+    };
+    if (checkCanFocusTrap) {
+      checkCanFocusTrap(this.state.containers.concat()).then(finishActivation, finishActivation);
+      return this;
+    }
+    finishActivation();
+    return this;
+  }
+};
+var isTabEvent = (event) => event.key === "Tab";
+var valueOrHandler = (value, ...params) => typeof value === "function" ? value(...params) : value;
+var isEscapeEvent = (event) => !event.isComposing && event.key === "Escape";
+var delay = (fn) => setTimeout(fn, 0);
+var isSelectableInput = (node) => node.localName === "input" && "select" in node && typeof node.select === "function";
+function trapFocus(el, options = {}) {
+  let trap;
+  const cleanup = raf$1(() => {
+    const contentEl = typeof el === "function" ? el() : el;
+    if (!contentEl) return;
+    trap = new FocusTrap(contentEl, {
+      escapeDeactivates: false,
+      allowOutsideClick: true,
+      preventScroll: true,
+      returnFocusOnDeactivate: true,
+      delayInitialFocus: false,
+      fallbackFocus: contentEl,
+      ...options,
+      document: getDocument(contentEl)
+    });
+    try {
+      trap.activate();
+    } catch {
+    }
+  });
+  return function destroy() {
+    trap == null ? void 0 : trap.deactivate();
+    cleanup();
+  };
+}
+var LOCK_CLASSNAME = "data-scroll-lock";
+function assignStyle(el, style) {
+  if (!el) return;
+  const previousStyle = Object.keys(style).reduce(
+    (acc, key) => {
+      acc[key] = el.style.getPropertyValue(key);
+      return acc;
+    },
+    {}
+  );
+  Object.assign(el.style, style);
+  return () => {
+    Object.assign(el.style, previousStyle);
+  };
+}
+function setCSSProperty(el, property, value) {
+  if (!el) return;
+  const previousValue = el.style.getPropertyValue(property);
+  el.style.setProperty(property, value);
+  return () => {
+    if (previousValue) {
+      el.style.setProperty(property, previousValue);
+    } else {
+      el.style.removeProperty(property);
+    }
+  };
+}
+function getPaddingProperty(documentElement) {
+  const documentLeft = documentElement.getBoundingClientRect().left;
+  const scrollbarX = Math.round(documentLeft) + documentElement.scrollLeft;
+  return scrollbarX ? "paddingLeft" : "paddingRight";
+}
+function preventBodyScroll(_document) {
+  const doc = _document ?? document;
+  const win = doc.defaultView ?? window;
+  const { documentElement, body } = doc;
+  const locked = body.hasAttribute(LOCK_CLASSNAME);
+  if (locked) return;
+  body.setAttribute(LOCK_CLASSNAME, "");
+  const scrollbarWidth = win.innerWidth - documentElement.clientWidth;
+  const setScrollbarWidthProperty = () => setCSSProperty(documentElement, "--scrollbar-width", `${scrollbarWidth}px`);
+  const paddingProperty = getPaddingProperty(documentElement);
+  const setStyle2 = () => assignStyle(body, {
+    overflow: "hidden",
+    [paddingProperty]: `${scrollbarWidth}px`
+  });
+  const setIOSStyle = () => {
+    const { scrollX, scrollY, visualViewport } = win;
+    const offsetLeft = (visualViewport == null ? void 0 : visualViewport.offsetLeft) ?? 0;
+    const offsetTop = (visualViewport == null ? void 0 : visualViewport.offsetTop) ?? 0;
+    const restoreStyle = assignStyle(body, {
+      position: "fixed",
+      overflow: "hidden",
+      top: `${-(scrollY - Math.floor(offsetTop))}px`,
+      left: `${-(scrollX - Math.floor(offsetLeft))}px`,
+      right: "0",
+      [paddingProperty]: `${scrollbarWidth}px`
+    });
+    return () => {
+      restoreStyle == null ? void 0 : restoreStyle();
+      win.scrollTo({ left: scrollX, top: scrollY, behavior: "instant" });
+    };
+  };
+  const cleanups2 = [setScrollbarWidthProperty(), isIos() ? setIOSStyle() : setStyle2()];
+  return () => {
+    cleanups2.forEach((fn) => fn == null ? void 0 : fn());
+    body.removeAttribute(LOCK_CLASSNAME);
+  };
+}
+var anatomy = createAnatomy("dialog").parts(
+  "trigger",
+  "backdrop",
+  "positioner",
+  "content",
+  "title",
+  "description",
+  "closeTrigger"
+);
+var parts = anatomy.build();
+var getPositionerId = (ctx) => {
+  var _a;
+  return ((_a = ctx.ids) == null ? void 0 : _a.positioner) ?? `dialog:${ctx.id}:positioner`;
+};
+var getBackdropId = (ctx) => {
+  var _a;
+  return ((_a = ctx.ids) == null ? void 0 : _a.backdrop) ?? `dialog:${ctx.id}:backdrop`;
+};
+var getContentId = (ctx) => {
+  var _a;
+  return ((_a = ctx.ids) == null ? void 0 : _a.content) ?? `dialog:${ctx.id}:content`;
+};
+var getTriggerId = (ctx) => {
+  var _a;
+  return ((_a = ctx.ids) == null ? void 0 : _a.trigger) ?? `dialog:${ctx.id}:trigger`;
+};
+var getTitleId = (ctx) => {
+  var _a;
+  return ((_a = ctx.ids) == null ? void 0 : _a.title) ?? `dialog:${ctx.id}:title`;
+};
+var getDescriptionId = (ctx) => {
+  var _a;
+  return ((_a = ctx.ids) == null ? void 0 : _a.description) ?? `dialog:${ctx.id}:description`;
+};
+var getCloseTriggerId = (ctx) => {
+  var _a;
+  return ((_a = ctx.ids) == null ? void 0 : _a.closeTrigger) ?? `dialog:${ctx.id}:close`;
+};
+var getContentEl = (ctx) => ctx.getById(getContentId(ctx));
+var getPositionerEl = (ctx) => ctx.getById(getPositionerId(ctx));
+var getBackdropEl = (ctx) => ctx.getById(getBackdropId(ctx));
+var getTriggerEl = (ctx) => ctx.getById(getTriggerId(ctx));
+var getTitleEl = (ctx) => ctx.getById(getTitleId(ctx));
+var getDescriptionEl = (ctx) => ctx.getById(getDescriptionId(ctx));
+var getCloseTriggerEl = (ctx) => ctx.getById(getCloseTriggerId(ctx));
+function connect(service, normalize) {
+  const { state, send, context: context2, prop, scope } = service;
+  const ariaLabel = prop("aria-label");
+  const open = state.matches("open");
+  return {
+    open,
+    setOpen(nextOpen) {
+      const open2 = state.matches("open");
+      if (open2 === nextOpen) return;
+      send({ type: nextOpen ? "OPEN" : "CLOSE" });
+    },
+    getTriggerProps() {
+      return normalize.button({
+        ...parts.trigger.attrs,
+        dir: prop("dir"),
+        id: getTriggerId(scope),
+        "aria-haspopup": "dialog",
+        type: "button",
+        "aria-expanded": open,
+        "data-state": open ? "open" : "closed",
+        "aria-controls": getContentId(scope),
+        onClick(event) {
+          if (event.defaultPrevented) return;
+          send({ type: "TOGGLE" });
+        }
+      });
+    },
+    getBackdropProps() {
+      return normalize.element({
+        ...parts.backdrop.attrs,
+        dir: prop("dir"),
+        hidden: !open,
+        id: getBackdropId(scope),
+        "data-state": open ? "open" : "closed"
+      });
+    },
+    getPositionerProps() {
+      return normalize.element({
+        ...parts.positioner.attrs,
+        dir: prop("dir"),
+        id: getPositionerId(scope),
+        style: {
+          pointerEvents: open ? void 0 : "none"
+        }
+      });
+    },
+    getContentProps() {
+      const rendered = context2.get("rendered");
+      return normalize.element({
+        ...parts.content.attrs,
+        dir: prop("dir"),
+        role: prop("role"),
+        hidden: !open,
+        id: getContentId(scope),
+        tabIndex: -1,
+        "data-state": open ? "open" : "closed",
+        "aria-modal": true,
+        "aria-label": ariaLabel || void 0,
+        "aria-labelledby": ariaLabel || !rendered.title ? void 0 : getTitleId(scope),
+        "aria-describedby": rendered.description ? getDescriptionId(scope) : void 0
+      });
+    },
+    getTitleProps() {
+      return normalize.element({
+        ...parts.title.attrs,
+        dir: prop("dir"),
+        id: getTitleId(scope)
+      });
+    },
+    getDescriptionProps() {
+      return normalize.element({
+        ...parts.description.attrs,
+        dir: prop("dir"),
+        id: getDescriptionId(scope)
+      });
+    },
+    getCloseTriggerProps() {
+      return normalize.button({
+        ...parts.closeTrigger.attrs,
+        dir: prop("dir"),
+        id: getCloseTriggerId(scope),
+        type: "button",
+        onClick(event) {
+          if (event.defaultPrevented) return;
+          event.stopPropagation();
+          send({ type: "CLOSE" });
+        }
+      });
+    }
+  };
+}
+var machine = createMachine({
+  props({ props: props2, scope }) {
+    const alertDialog = props2.role === "alertdialog";
+    const initialFocusEl = alertDialog ? () => getCloseTriggerEl(scope) : void 0;
+    return {
+      role: "dialog",
+      modal: true,
+      trapFocus: true,
+      preventScroll: true,
+      closeOnInteractOutside: !alertDialog,
+      closeOnEscape: true,
+      restoreFocus: true,
+      initialFocusEl,
+      ...props2
+    };
+  },
+  initialState({ prop }) {
+    const open = prop("open") || prop("defaultOpen");
+    return open ? "open" : "closed";
+  },
+  context({ bindable }) {
+    return {
+      rendered: bindable(() => ({
+        defaultValue: { title: true, description: true }
+      }))
+    };
+  },
+  watch({ track, action, prop }) {
+    track([() => prop("open")], () => {
+      action(["toggleVisibility"]);
+    });
+  },
+  states: {
+    open: {
+      entry: ["checkRenderedElements", "syncZIndex"],
+      effects: ["trackDismissableElement", "trapFocus", "preventScroll", "hideContentBelow"],
+      on: {
+        "CONTROLLED.CLOSE": {
+          target: "closed"
+        },
+        CLOSE: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        TOGGLE: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ]
+      }
+    },
+    closed: {
+      on: {
+        "CONTROLLED.OPEN": {
+          target: "open"
+        },
+        OPEN: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen"]
+          }
+        ],
+        TOGGLE: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["invokeOnOpen"]
+          }
+        ]
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      isOpenControlled: ({ prop }) => prop("open") != void 0
+    },
+    effects: {
+      trackDismissableElement({ scope, send, prop }) {
+        const getContentEl2 = () => getContentEl(scope);
+        return trackDismissableElement(getContentEl2, {
+          defer: true,
+          pointerBlocking: prop("modal"),
+          exclude: [getTriggerEl(scope)],
+          onInteractOutside(event) {
+            var _a;
+            (_a = prop("onInteractOutside")) == null ? void 0 : _a(event);
+            if (!prop("closeOnInteractOutside")) {
+              event.preventDefault();
+            }
+          },
+          persistentElements: prop("persistentElements"),
+          onFocusOutside: prop("onFocusOutside"),
+          onPointerDownOutside: prop("onPointerDownOutside"),
+          onEscapeKeyDown(event) {
+            var _a;
+            (_a = prop("onEscapeKeyDown")) == null ? void 0 : _a(event);
+            if (!prop("closeOnEscape")) {
+              event.preventDefault();
+            }
+          },
+          onDismiss() {
+            send({ type: "CLOSE", src: "interact-outside" });
+          }
+        });
+      },
+      preventScroll({ scope, prop }) {
+        if (!prop("preventScroll")) return;
+        return preventBodyScroll(scope.getDoc());
+      },
+      trapFocus({ scope, prop }) {
+        if (!prop("trapFocus") || !prop("modal")) return;
+        const contentEl = () => getContentEl(scope);
+        return trapFocus(contentEl, {
+          preventScroll: true,
+          returnFocusOnDeactivate: !!prop("restoreFocus"),
+          initialFocus: prop("initialFocusEl"),
+          setReturnFocus: (el) => {
+            var _a;
+            return ((_a = prop("finalFocusEl")) == null ? void 0 : _a()) ?? el;
+          }
+        });
+      },
+      hideContentBelow({ scope, prop }) {
+        if (!prop("modal")) return;
+        const getElements = () => [getContentEl(scope)];
+        return ariaHidden(getElements, { defer: true });
+      }
+    },
+    actions: {
+      checkRenderedElements({ context: context2, scope }) {
+        raf$1(() => {
+          context2.set("rendered", {
+            title: !!getTitleEl(scope),
+            description: !!getDescriptionEl(scope)
+          });
+        });
+      },
+      syncZIndex({ scope }) {
+        raf$1(() => {
+          const contentEl = getContentEl(scope);
+          if (!contentEl) return;
+          const styles = getComputedStyle(contentEl);
+          const elems = [getPositionerEl(scope), getBackdropEl(scope)];
+          elems.forEach((node) => {
+            node == null ? void 0 : node.style.setProperty("--z-index", styles.zIndex);
+          });
+        });
+      },
+      invokeOnClose({ prop }) {
+        var _a;
+        (_a = prop("onOpenChange")) == null ? void 0 : _a({ open: false });
+      },
+      invokeOnOpen({ prop }) {
+        var _a;
+        (_a = prop("onOpenChange")) == null ? void 0 : _a({ open: true });
+      },
+      toggleVisibility({ prop, send, event }) {
+        send({
+          type: prop("open") ? "CONTROLLED.OPEN" : "CONTROLLED.CLOSE",
+          previousEvent: event
+        });
+      }
+    }
+  }
+});
+createProps()([
+  "aria-label",
+  "closeOnEscape",
+  "closeOnInteractOutside",
+  "dir",
+  "finalFocusEl",
+  "getRootNode",
+  "getRootNode",
+  "id",
+  "id",
+  "ids",
+  "initialFocusEl",
+  "modal",
+  "onEscapeKeyDown",
+  "onFocusOutside",
+  "onInteractOutside",
+  "onOpenChange",
+  "onPointerDownOutside",
+  "defaultOpen",
+  "open",
+  "persistentElements",
+  "preventScroll",
+  "restoreFocus",
+  "role",
+  "trapFocus"
+]);
+const useDialog = (props) => {
+  const id = React.useId();
+  const { getRootNode } = useEnvironmentContext();
+  const { dir } = useLocaleContext();
+  const machineProps = {
+    id,
+    getRootNode,
+    dir,
+    ...props
+  };
+  const service = useMachine(machine, machineProps);
+  return connect(service, normalizeProps);
+};
+const DialogRoot = (props) => {
+  const [presenceProps, { children, ...localProps }] = splitPresenceProps(props);
+  const [renderStrategyProps] = splitRenderStrategyProps(presenceProps);
+  const dialog = useDialog(localProps);
+  const presence = usePresence(mergeProps({ present: dialog.open }, presenceProps));
+  return /* @__PURE__ */ jsxRuntime.jsx(DialogProvider, { value: dialog, children: /* @__PURE__ */ jsxRuntime.jsx(RenderStrategyPropsProvider, { value: renderStrategyProps, children: /* @__PURE__ */ jsxRuntime.jsx(PresenceProvider, { value: presence, children }) }) });
+};
+const DialogTitle = React.forwardRef((props, ref) => {
+  const dialog = useDialogContext();
+  const mergedProps = mergeProps(dialog.getTitleProps(), props);
+  return /* @__PURE__ */ jsxRuntime.jsx(ark.h2, { ...mergedProps, ref });
+});
+DialogTitle.displayName = "DialogTitle";
+const DialogTrigger = React.forwardRef((props, ref) => {
+  const dialog = useDialogContext();
+  const presence = usePresenceContext();
+  const mergedProps = mergeProps(
+    {
+      ...dialog.getTriggerProps(),
+      "aria-controls": presence.unmounted ? void 0 : dialog.getTriggerProps()["aria-controls"]
+    },
+    props
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(ark.button, { ...mergedProps, ref });
+});
+DialogTrigger.displayName = "DialogTrigger";
+const Portal = (props) => {
+  var _a;
+  const { children, disabled } = props;
+  const [container, setContainer] = React.useState((_a = props.container) == null ? void 0 : _a.current);
+  const isServer = React.useSyncExternalStore(
+    subscribe,
+    () => false,
+    () => true
+  );
+  const { getRootNode } = useEnvironmentContext();
+  React.useEffect(() => {
+    setContainer(() => {
+      var _a2;
+      return (_a2 = props.container) == null ? void 0 : _a2.current;
+    });
+  }, [props.container]);
+  if (isServer || disabled) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+  const mountNode = container ?? getPortalNode(getRootNode);
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: React.Children.map(children, (child) => reactDom.createPortal(child, mountNode)) });
+};
+const getPortalNode = (cb) => {
+  const node = cb == null ? void 0 : cb();
+  const rootNode = node.getRootNode();
+  if (isShadowRoot(rootNode)) return rootNode;
+  return getDocument(node).body;
+};
+const subscribe = () => () => {
+};
+const spinnerRecipe = cva({
+  base: {
+    display: "inline-block",
+    borderWidth: "md",
+    borderStyle: "solid",
+    borderStartEndRadius: "full",
+    borderEndStartRadius: "full",
+    borderRadius: "full",
+    animation: "spin",
+    animationDuration: "slowest"
+  },
+  defaultVariants: {
+    size: "md"
+  },
+  variants: {
+    size: {
+      sm: { width: 4, height: 4 },
+      md: { width: 6, height: 6 },
+      lg: { width: 12, height: 12 },
+      xl: { width: 24, height: 24 }
+    }
+  }
+});
+const Spinner = React.forwardRef((props, ref) => {
+  const { label = "Loading...", color, ...rest } = props;
+  const StyledSpinner = styled(ark.div, spinnerRecipe);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    StyledSpinner,
+    {
+      ref,
+      ...rest,
+      borderColor: "inherit",
+      borderBottomColor: "transparent",
+      borderLeftColor: "transparent",
+      children: label && /* @__PURE__ */ jsxRuntime.jsx(styled.span, { srOnly: true, children: label })
+    }
+  );
+});
+Spinner.displayName = "Spinner";
+const buttonRecipe = cva({
+  base: {
+    alignItems: "center",
+    appearance: "none",
+    cursor: "pointer",
+    display: "inline-flex",
+    fontWeight: "semibold",
+    isolation: "isolate",
+    minWidth: "0",
+    justifyContent: "center",
+    outline: "none",
+    position: "relative",
+    transitionDuration: "normal",
+    transitionProperty: "background, border-color, color, box-shadow",
+    transitionTimingFunction: "default",
+    userSelect: "none",
+    verticalAlign: "middle",
+    whiteSpace: "nowrap",
+    _hidden: {
+      display: "none"
+    }
+  },
+  defaultVariants: {
+    variant: "solid",
+    size: "md",
+    radius: "full",
+    color: "neutral"
+  },
+  variants: {
+    variant: {
+      solid: {
+        _disabled: {
+          background: "background.neutral.disabled",
+          color: "content.neutral.disabled",
+          cursor: "not-allowed",
+          pointerEvents: "none"
+        }
+      },
+      outline: {
+        background: "transparent",
+        borderWidth: "1px",
+        borderStyle: "solid",
+        borderColor: "border.neutral.default",
+        _disabled: {
+          background: "transparent",
+          color: "content.neutral.disabled",
+          borderColor: "border.neutral.disabled",
+          cursor: "not-allowed",
+          pointerEvents: "none"
+        }
+      },
+      light: {
+        background: "transparent",
+        _disabled: {
+          background: "transparent",
+          color: "content.neutral.disabled",
+          cursor: "not-allowed",
+          pointerEvents: "none"
+        }
+      }
+    },
+    color: {
+      neuroid_primary: {},
+      neuroid_secondary: {},
+      zoltarina_primary: {},
+      zoltarina_secondary: {},
+      heyd_primary: {},
+      heyd_secondary: {},
+      heybee_primary: {},
+      neutral: {},
+      danger: {},
+      warning: {},
+      success: {},
+      informative: {}
+    },
+    size: {
+      xs: {
+        h: 7,
+        textStyle: "label.sm",
+        px: "8px",
+        gap: 1,
+        "& :where(svg)": {
+          width: "20px",
+          height: "20px"
+        }
+      },
+      sm: {
+        h: 8,
+        textStyle: "label.sm",
+        px: "16px",
+        gap: 1,
+        "& :where(svg)": {
+          width: "20px",
+          height: "20px"
+        }
+      },
+      md: {
+        h: 10,
+        textStyle: "label.md",
+        px: "20px",
+        gap: 1,
+        "& :where(svg)": {
+          width: "24px",
+          height: "24px"
+        }
+      },
+      lg: {
+        h: 12,
+        textStyle: "body.lg",
+        px: "28px",
+        gap: 1,
+        "& :where(svg)": {
+          width: "24px",
+          height: "24px"
+        }
+      }
+    },
+    radius: {
+      full: { borderRadius: "full" },
+      lg: { borderRadius: "lg" },
+      md: { borderRadius: "md" }
+    },
+    fullWidth: {
+      true: {
+        width: "full",
+        flexBasis: "auto",
+        flexGrow: 1
+      }
+    }
+  },
+  compoundVariants: [
+    {
+      variant: "solid",
+      color: "neuroid_primary",
+      css: {
+        background: "background.neuroidPrimary.default",
+        color: "content.neutral.bold",
+        _hover: { background: "background.neuroidPrimary.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "neuroid_secondary",
+      css: {
+        background: "background.neuroidSecondary.default",
+        color: "content.static.black.bold",
+        _hover: { background: "background.neuroidSecondary.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "zoltarina_primary",
+      css: {
+        background: "background.zoltarinaPrimary.default",
+        color: "content.static.black.bold",
+        _hover: { background: "background.zoltarinaPrimary.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "zoltarina_secondary",
+      css: {
+        background: "background.zoltarinaSecondary.default",
+        color: "content.static.black.bold",
+        _hover: { background: "background.zoltarinaSecondary.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "heyd_primary",
+      css: {
+        background: "background.heydPrimary.default",
+        color: "content.static.black.bold",
+        _hover: { background: "background.heydPrimary.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "heyd_secondary",
+      css: {
+        background: "background.heydSecondary.default",
+        color: "content.static.black.bold",
+        _hover: { background: "background.heydSecondary.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "heybee_primary",
+      css: {
+        background: "background.heybeePrimary.default",
+        color: "content.static.black.bold",
+        _hover: { background: "background.heybeePrimary.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "neutral",
+      css: {
+        background: "background.neutral.default",
+        color: "content.neutral.bold",
+        _hover: { background: "background.neutral.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "danger",
+      css: {
+        background: "background.danger.default",
+        color: "content.neutral.bold",
+        _hover: { background: "background.danger.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "warning",
+      css: {
+        background: "background.warning.default",
+        color: "content.neutral.bold",
+        _hover: { background: "background.warning.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "success",
+      css: {
+        background: "background.success.default",
+        color: "content.neutral.bold",
+        _hover: { background: "background.success.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "informative",
+      css: {
+        background: "background.informative.default",
+        color: "content.neutral.bold",
+        _hover: { background: "background.informative.selected" }
+      }
+    },
+    {
+      variant: "outline",
+      color: "neuroid_primary",
+      css: {
+        color: "content.neuroidPrimary.default",
+        borderColor: "border.neuroidPrimary.default",
+        _hover: {
+          background: "background.neuroidPrimary.selected",
+          color: "content.neutral.bold"
+        }
+      }
+    },
+    {
+      variant: "outline",
+      color: "zoltarina_primary",
+      css: {
+        color: "content.zoltarinaPrimary.default",
+        borderColor: "border.zoltarinaPrimary.default",
+        _hover: {
+          background: "background.zoltarinaPrimary.selected",
+          color: "content.neutral.bold"
+        }
+      }
+    },
+    {
+      variant: "outline",
+      color: "heyd_primary",
+      css: {
+        color: "content.heydPrimary.default",
+        borderColor: "border.heydPrimary.default",
+        _hover: {
+          background: "background.heydPrimary.selected",
+          color: "content.neutral.bold"
+        }
+      }
+    },
+    {
+      variant: "outline",
+      color: "heybee_primary",
+      css: {
+        color: "content.heybeePrimary.default",
+        borderColor: "border.heybeePrimary.default",
+        _hover: {
+          background: "background.heybeePrimary.selected",
+          color: "content.neutral.bold"
+        }
+      }
+    },
+    {
+      variant: "outline",
+      color: "neutral",
+      css: {
+        color: "content.neutral.default",
+        borderColor: "border.neutral.default",
+        _hover: {
+          background: "background.neutral.selected",
+          color: "content.neutral.bold"
+        }
+      }
+    },
+    {
+      variant: "outline",
+      color: "danger",
+      css: {
+        color: "content.danger.default",
+        borderColor: "border.danger.default",
+        _hover: {
+          background: "background.danger.selected",
+          color: "content.neutral.bold"
+        }
+      }
+    },
+    {
+      variant: "outline",
+      color: "warning",
+      css: {
+        color: "content.warning.default",
+        borderColor: "border.warning.default",
+        _hover: {
+          background: "background.warning.selected",
+          color: "content.neutral.bold"
+        }
+      }
+    },
+    {
+      variant: "outline",
+      color: "success",
+      css: {
+        color: "content.success.default",
+        borderColor: "border.success.default",
+        _hover: {
+          background: "background.success.selected",
+          color: "content.neutral.bold"
+        }
+      }
+    },
+    {
+      variant: "outline",
+      color: "informative",
+      css: {
+        color: "content.informative.default",
+        borderColor: "border.informative.default",
+        _hover: {
+          background: "background.informative.selected",
+          color: "content.neutral.bold"
+        }
+      }
+    },
+    {
+      variant: "light",
+      color: "neuroid_primary",
+      css: {
+        background: "transparent",
+        color: "content.neuroidPrimary.default",
+        _hover: {
+          textDecoration: "underline"
+        }
+      }
+    },
+    {
+      variant: "light",
+      color: "zoltarina_primary",
+      css: {
+        background: "transparent",
+        color: "content.zoltarinaPrimary.default",
+        _hover: {
+          textDecoration: "underline"
+        }
+      }
+    },
+    {
+      variant: "light",
+      color: "heyd_primary",
+      css: {
+        background: "transparent",
+        color: "content.heydPrimary.default",
+        _hover: {
+          textDecoration: "underline"
+        }
+      }
+    },
+    {
+      variant: "light",
+      color: "heybee_primary",
+      css: {
+        background: "transparent",
+        color: "content.heybeePrimary.default",
+        _hover: {
+          textDecoration: "underline"
+        }
+      }
+    },
+    {
+      variant: "light",
+      color: "neutral",
+      css: {
+        background: "transparent",
+        color: "content.neutral.bold",
+        _hover: {
+          textDecoration: "underline"
+        }
+      }
+    },
+    {
+      variant: "light",
+      color: "danger",
+      css: {
+        background: "transparent",
+        color: "content.danger.default",
+        _hover: {
+          textDecoration: "underline"
+        }
+      }
+    },
+    {
+      variant: "light",
+      color: "warning",
+      css: {
+        background: "transparent",
+        color: "content.warning.default",
+        _hover: {
+          textDecoration: "underline"
+        }
+      }
+    },
+    {
+      variant: "light",
+      color: "success",
+      css: {
+        background: "transparent",
+        color: "content.success.default",
+        _hover: {
+          textDecoration: "underline"
+        }
+      }
+    },
+    {
+      variant: "light",
+      color: "informative",
+      css: {
+        background: "transparent",
+        color: "content.informative.default",
+        _hover: {
+          textDecoration: "underline"
+        }
+      }
+    }
+  ]
+});
+const Button = React.forwardRef(
+  ({ loading, disabled, loadingText, children, color, variant, size, radius, ...rest }, ref) => {
+    const StyledButton = styled(ark.button, buttonRecipe);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      StyledButton,
+      {
+        disabled,
+        ref,
+        color,
+        variant,
+        size,
+        radius,
+        pointerEvents: loading ? "none" : "auto",
+        ...rest,
+        children: loading ? loadingText || /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(Center, { inline: true, position: "absolute", transform: "translate(-50%, -50%)", top: "50%", insetStart: "50%", children: /* @__PURE__ */ jsxRuntime.jsx(Spinner, { size: size === "xs" || size === "sm" ? "sm" : "md" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(styled.span, { opacity: 0, children })
+        ] }) : children
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+const textRecipe = cva({
+  base: {
+    color: "content.neutral.default"
+  },
+  defaultVariants: {
+    variant: "body.md"
+  },
+  variants: {
+    variant: {
+      "display.lg": {
+        textStyle: "display.lg"
+      },
+      "display.md": {
+        textStyle: "display.md"
+      },
+      "headline.md": {
+        textStyle: "headline.md"
+      },
+      "headline.sm": {
+        textStyle: "headline.sm"
+      },
+      "title.lg": {
+        textStyle: "title.lg"
+      },
+      "title.md": {
+        textStyle: "title.md"
+      },
+      "body.lg": {
+        textStyle: "body.lg"
+      },
+      "body.md": {
+        textStyle: "body.md"
+      },
+      "body.sm": {
+        textStyle: "body.sm"
+      },
+      "label.sm": {
+        textStyle: "label.sm"
+      },
+      "label.md": {
+        textStyle: "label.md"
+      }
+    }
+  }
+});
+const Text = React.forwardRef((props, ref) => {
+  const { variant = "body.md", children, ...rest } = props;
+  const textType = (variant == null ? void 0 : variant.split(".")[0]) || "body";
+  const componentMap = {
+    display: styled("h1", textRecipe),
+    headline: styled("h2", textRecipe),
+    title: styled("h3", textRecipe),
+    body: styled("p", textRecipe),
+    label: styled("span", textRecipe)
+  };
+  const TextComponent = componentMap[textType];
+  return /* @__PURE__ */ jsxRuntime.jsx(TextComponent, { ref, textStyle: variant, ...rest, children });
+});
+Text.displayName = "Text";
+const shouldForwardProp = (prop, variantKeys, options = {}) => {
+  var _a;
+  return ((_a = options.forwardProps) == null ? void 0 : _a.includes(prop)) || !variantKeys.includes(prop) && !isCssProperty(prop);
+};
+const createStyleContext = (recipe) => {
+  const StyleContext = React.createContext(null);
+  const withRootProvider2 = (Component) => {
+    const StyledComponent = (props) => {
+      const [variantProps, otherProps] = recipe.splitVariantProps(props);
+      const slotStyles = recipe(variantProps);
+      return /* @__PURE__ */ jsxRuntime.jsx(StyleContext.Provider, { value: slotStyles, children: /* @__PURE__ */ jsxRuntime.jsx(Component, { ...otherProps }) });
+    };
+    return StyledComponent;
+  };
+  const withProvider = (Component, slot, options) => {
+    const StyledComponent = styled(
+      Component,
+      {},
+      {
+        shouldForwardProp: (prop, variantKeys) => shouldForwardProp(prop, variantKeys, options)
+      }
+    );
+    const StyledSlotProvider = React.forwardRef((props, ref) => {
+      const [variantProps, otherProps] = recipe.splitVariantProps(props);
+      const slotStyles = recipe(variantProps);
+      return /* @__PURE__ */ jsxRuntime.jsx(StyleContext.Provider, { value: slotStyles, children: /* @__PURE__ */ jsxRuntime.jsx(StyledComponent, { ...otherProps, ref, className: cx(slotStyles == null ? void 0 : slotStyles[slot], props.className) }) });
+    });
+    StyledSlotProvider.displayName = Component.displayName || Component.name;
+    return StyledSlotProvider;
+  };
+  const withContext2 = (Component, slot) => {
+    const StyledComponent = styled(Component);
+    const StyledSlotComponent = React.forwardRef((props, ref) => {
+      const slotStyles = React.useContext(StyleContext);
+      return /* @__PURE__ */ jsxRuntime.jsx(StyledComponent, { ...props, ref, className: cx(slotStyles == null ? void 0 : slotStyles[slot], props.className) });
+    });
+    StyledSlotComponent.displayName = Component.displayName || Component.name;
+    return StyledSlotComponent;
+  };
+  return {
+    withRootProvider: withRootProvider2,
+    withProvider,
+    withContext: withContext2
+  };
+};
+const dialogRecipe = sva({
+  className: "dialog",
+  slots: anatomy.keys(),
+  base: {
+    backdrop: {
+      backdropFilter: "blur(4px)",
+      background: {
+        _light: "white.100A",
+        _dark: "black.100A"
+      },
+      height: "100vh",
+      left: "0",
+      position: "fixed",
+      top: "0",
+      width: "100vw",
+      zIndex: "overlay",
+      _open: {
+        animation: "backdrop-in"
+      },
+      _closed: {
+        animation: "backdrop-out"
+      }
+    },
+    positioner: {
+      alignItems: "center",
+      display: "flex",
+      justifyContent: "center",
+      left: "0",
+      overflow: "auto",
+      position: "fixed",
+      top: "0",
+      width: "full",
+      height: "full",
+      zIndex: "modal"
+    },
+    content: {
+      background: "white",
+      borderRadius: "sm",
+      boxShadow: "overlay",
+      minW: "sm",
+      position: "relative",
+      p: "3",
+      _open: {
+        animation: "dialog-in"
+      },
+      _closed: {
+        animation: "dialog-out"
+      }
+    },
+    title: {
+      textStyle: "title.lg"
+    },
+    description: {
+      color: "content.neutral.default_inverse",
+      textStyle: "body.md"
+    }
+  }
+});
+const { withRootProvider, withContext } = createStyleContext(dialogRecipe);
+const Root = withRootProvider(DialogRoot);
+const Backdrop = withContext(DialogBackdrop, "backdrop");
+const Trigger = withContext(DialogTrigger, "trigger");
+const Content = withContext(DialogContent, "content");
+const Title = withContext(DialogTitle, "title");
+const Description = withContext(DialogDescription, "description");
+const Positioner = withContext(DialogPositioner, "positioner");
+const Dialog = {
+  Root,
+  Backdrop,
+  Trigger,
+  Content,
+  Title,
+  Description,
+  Positioner
+};
+const iconButtonRecipe = cva({
+  base: {
+    alignItems: "center",
+    appearance: "none",
+    cursor: "pointer",
+    display: "inline-flex",
+    isolation: "isolate",
+    minWidth: "0",
+    justifyContent: "center",
+    outline: "none",
+    position: "relative",
+    transitionDuration: "normal",
+    transitionProperty: "background, border-color, color, box-shadow",
+    transitionTimingFunction: "default",
+    userSelect: "none",
+    verticalAlign: "middle",
+    borderRadius: "full",
+    color: "content.neutral.bold",
+    _hidden: {
+      display: "none"
+    }
+  },
+  defaultVariants: {
+    variant: "solid",
+    size: "md",
+    color: "neutral"
+  },
+  variants: {
+    variant: {
+      solid: {
+        _disabled: {
+          background: "background.neutral.disabled",
+          color: "content.neutral.disabled",
+          cursor: "not-allowed",
+          pointerEvents: "none"
+        }
+      },
+      outline: {
+        background: "transparent",
+        borderWidth: "1px",
+        borderStyle: "solid",
+        borderColor: "border.neutral.default",
+        color: "content.neutral.bold",
+        _disabled: {
+          background: "transparent",
+          color: "content.neutral.disabled",
+          borderColor: "border.neutral.disabled",
+          cursor: "not-allowed",
+          pointerEvents: "none"
+        },
+        _hover: {
+          background: "background.neutral.selected"
+        }
+      },
+      light: {
+        background: "transparent",
+        color: "content.neutral.bold",
+        _disabled: {
+          background: "transparent",
+          color: "content.neutral.disabled",
+          cursor: "not-allowed",
+          pointerEvents: "none"
+        },
+        _hover: {
+          background: "background.neutral.selected"
+        }
+      }
+    },
+    color: {
+      neuroid_primary: {},
+      zoltarina_primary: {},
+      heyd_primary: {},
+      heybee_primary: {},
+      neutral: {}
+    },
+    size: {
+      sm: {
+        h: 7,
+        w: 7,
+        p: "4px",
+        "& :where(svg)": {
+          width: "20px",
+          height: "20px"
+        }
+      },
+      md: {
+        h: 8,
+        w: 8,
+        p: "4px",
+        "& :where(svg)": {
+          width: "24px",
+          height: "24px"
+        }
+      },
+      lg: {
+        h: 10,
+        w: 10,
+        p: "8px",
+        "& :where(svg)": {
+          width: "24px",
+          height: "24px"
+        }
+      }
+    }
+  },
+  compoundVariants: [
+    {
+      variant: "solid",
+      color: "neuroid_primary",
+      css: {
+        background: "background.neuroidPrimary.default",
+        color: "content.neutral.bold",
+        _hover: { background: "background.neuroidPrimary.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "zoltarina_primary",
+      css: {
+        background: "background.zoltarinaPrimary.default",
+        color: "content.static.black.bold",
+        _hover: { background: "background.zoltarinaPrimary.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "heyd_primary",
+      css: {
+        background: "background.heydPrimary.default",
+        color: "content.static.black.bold",
+        _hover: { background: "background.heydPrimary.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "heybee_primary",
+      css: {
+        background: "background.heybeePrimary.default",
+        color: "content.static.black.bold",
+        _hover: { background: "background.heybeePrimary.selected" }
+      }
+    },
+    {
+      variant: "solid",
+      color: "neutral",
+      css: {
+        background: "background.neutral.default",
+        color: "content.neutral.bold",
+        _hover: { background: "background.neutral.selected" }
+      }
+    }
+  ]
+});
+const IconButton = React.forwardRef(
+  ({ loading, disabled, children, color, variant, size, ...rest }, ref) => {
+    const StyledButton = styled(ark.button, iconButtonRecipe);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      StyledButton,
+      {
+        disabled,
+        ref,
+        color,
+        variant,
+        size,
+        pointerEvents: loading ? "none" : "auto",
+        ...rest,
+        children: loading ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(Center, { inline: true, position: "absolute", transform: "translate(-50%, -50%)", top: "50%", insetStart: "50%", children: /* @__PURE__ */ jsxRuntime.jsx(Spinner, { size: size === "lg" ? "md" : "sm" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(styled.span, { opacity: 0, children })
+        ] }) : children
+      }
+    );
+  }
+);
+IconButton.displayName = "IconButton";
+function definePreset(preset2) {
+  return preset2;
+}
+function defineKeyframes(keyframes2) {
+  return keyframes2;
+}
+function defineGlobalStyles(definition) {
+  return definition;
+}
+function createProxy() {
+  const identity2 = (v2) => v2;
+  return new Proxy(identity2, {
+    get() {
+      return identity2;
+    }
+  });
+}
+var defineTokens = /* @__PURE__ */ createProxy();
+const globalCss = defineGlobalStyles({});
+const keyframes = defineKeyframes({
+  "fade-in": {
+    from: { opacity: "0" },
+    to: { opacity: "1" }
+  },
+  "fade-out": {
+    from: { opacity: "1" },
+    to: { opacity: "0" }
+  },
+  "slide-in": {
+    "0%": { opacity: "0", transform: "translateY(64px)" },
+    "100%": { opacity: "1", transform: "translateY(0)" }
+  },
+  "slide-out": {
+    "0%": { opacity: "1", transform: "translateY(0)" },
+    "100%": { opacity: "0", transform: "translateY(64px)" }
+  },
+  "slide-in-left": {
+    "0%": { transform: "translateX(-100%)" },
+    "100%": { transform: "translateX(0%)" }
+  },
+  "slide-out-left": {
+    "0%": { transform: "translateX(0%)" },
+    "100%": { transform: "translateX(-100%)" }
+  },
+  "slide-in-right": {
+    "0%": { transform: "translateX(100%)" },
+    "100%": { transform: "translateX(0%)" }
+  },
+  "slide-out-right": {
+    "0%": { transform: "translateX(0%)" },
+    "100%": { transform: "translateX(100%)" }
+  },
+  "collapse-in": {
+    "0%": { height: "0" },
+    "100%": { height: "var(--height)" }
+  },
+  "collapse-out": {
+    "0%": { height: "var(--height)" },
+    "100%": { height: "0" }
+  },
+  fadeIn: {
+    "0%": { opacity: "0", transform: "translateY(-4px)" },
+    "100%": { opacity: "1", transform: "translateY(0)" }
+  },
+  fadeOut: {
+    "0%": { opacity: "1", transform: "translateY(0)" },
+    "100%": { opacity: "0", transform: "translateY(-4px)" }
+  },
+  "skeleton-pulse": {
+    "50%": { opacity: "0.5" }
+  },
+  spin: {
+    "0%": { transform: "rotate(0deg)" },
+    "100%": { transform: "rotate(360deg)" }
+  }
+});
+var m = { colors: { content: { neutral: { bold: { value: { base: "{colors.neutral.0}", _dark: "{colors.neutral.1100}" } }, default: { value: { base: "{colors.neutral.300}", _dark: "{colors.neutral.1000}" } }, subtle: { value: { base: "{colors.neutral.600}", _dark: "{colors.neutral.900}" } }, subtlest: { value: { base: "{colors.neutral.900}", _dark: "{colors.neutral.500}" } }, disabled: { value: { base: "{colors.neutral.800}", _dark: "{colors.neutral.600}" } }, default_inverse: { value: { base: "{colors.neutral.1100}", _dark: "{colors.neutral.0}" } } }, neuroidPrimary: { default: { value: { base: "{colors.purple.500}", _dark: "{colors.purple.400}" } }, default_inverse: { value: { base: "{colors.purple.800}", _dark: "{colors.purple.800}" } } }, danger: { default: { value: { base: "{colors.red.600}", _dark: "{colors.red.400}" } } }, warning: { default: { value: { base: "{colors.orange.600}", _dark: "{colors.orange.400}" } } }, success: { default: { value: { base: "{colors.green.600}", _dark: "{colors.green.400}" } } }, informative: { default: { value: { base: "{colors.blue.600}", _dark: "{colors.blue.400}" } } }, zoltarinaPrimary: { default: { value: { base: "{colors.ohre.800}", _dark: "{colors.ohre.400}" } }, defult_inverse: { value: { base: "{colors.ohre.1000}", _dark: "{colors.ohre.1000}" } } }, heydPrimary: { default: { value: { base: "{colors.cyan.800}", _dark: "{colors.cyan.400}" } }, defult_inverse: { value: { base: "{colors.cyan.1000}", _dark: "{colors.cyan.1000}" } } }, static: { white: { bold: { value: { base: "{colors.neutral.1200}", _dark: "{colors.neutral.1200}" } }, default: { value: { base: "{colors.neutral.1050}", _dark: "{colors.neutral.1050}" } }, subtle: { value: { base: "{colors.neutral.1000}", _dark: "{colors.neutral.1000}" } }, subtlest: { value: { base: "{colors.neutral.900}", _dark: "{colors.neutral.900}" } }, disabled: { value: { base: "{colors.neutral.800}", _dark: "{colors.neutral.800}" } } }, black: { bold: { value: { base: "{colors.neutral.0}", _dark: "{colors.neutral.0}" } }, default: { value: { base: "{colors.neutral.200}", _dark: "{colors.neutral.200}" } }, subtle: { value: { base: "{colors.neutral.400}", _dark: "{colors.neutral.400}" } }, subtlest: { value: { base: "{colors.neutral.600}", _dark: "{colors.neutral.600}" } }, disabled: { value: { base: "{colors.neutral.800}", _dark: "{colors.neutral.800}" } } } }, heybeePrimary: { default: { value: { base: "{colors.yellow.800}", _dark: "{colors.yellow.500}" } }, default_inverse: { value: { base: "{colors.yellow.1000}", _dark: "{colors.yellow.1000}" } } } }, background: { neutral: { default: { value: { base: "{colors.neutral.1050}", _dark: "{colors.neutral.200}" } }, selected: { value: { base: "{colors.neutral.1000}", _dark: "{colors.neutral.300}" } }, disabled: { value: { base: "{colors.neutral.1000}", _dark: "{colors.neutral.400}" } } }, neuroidPrimary: { default: { value: { base: "{colors.purple.300}", _dark: "{colors.purple.600}" } }, selected: { value: { base: "{colors.purple.400}", _dark: "{colors.purple.700}" } } }, neuroidSecondary: { default: { value: { base: "{colors.purple.200}", _dark: "{colors.purple.300}" } }, selected: { value: { base: "{colors.purple.300}", _dark: "{colors.purple.400}" } } }, danger: { default: { value: { base: "{colors.red.300}", _dark: "{colors.red.700}" } }, selected: { value: { base: "{colors.red.400}", _dark: "{colors.red.800}" } } }, warning: { default: { value: { base: "{colors.orange.300}", _dark: "{colors.orange.700}" } }, selected: { value: { base: "{colors.orange.400}", _dark: "{colors.orange.800}" } } }, success: { default: { value: { base: "{colors.green.300}", _dark: "{colors.green.700}" } }, selected: { value: { base: "{colors.green.400}", _dark: "{colors.green.800}" } } }, informative: { default: { value: { base: "{colors.blue.300}", _dark: "{colors.blue.700}" } }, selected: { value: { base: "{colors.blue.400}", _dark: "{colors.blue.800}" } } }, zoltarinaPrimary: { default: { value: { base: "{colors.ohre.400}", _dark: "{colors.ohre.400}" } }, selected: { value: { base: "{colors.ohre.500}", _dark: "{colors.ohre.500}" } } }, zoltarinaSecondary: { default: { value: { base: "{colors.ohre.200}", _dark: "{colors.ohre.200}" } }, selected: { value: { base: "{colors.ohre.300}", _dark: "{colors.ohre.300}" } } }, heydPrimary: { default: { value: { base: "{colors.cyan.500}", _dark: "{colors.cyan.500}" } }, selected: { value: { base: "{colors.cyan.600}", _dark: "{colors.cyan.600}" } } }, heydSecondary: { default: { value: { base: "{colors.cyan.200}", _dark: "{colors.cyan.200}" } }, selected: { value: { base: "{colors.cyan.300}", _dark: "{colors.cyan.300}" } } }, static: { whiteAlpha: { bold: { value: { base: "{colors.white.700A}", _dark: "{colors.white.700A}" } }, default: { value: { base: "{colors.white.500A}", _dark: "{colors.white.500A}" } }, selected: { value: { base: "{colors.white.600A}", _dark: "{colors.white.600A}" } }, disabled: { value: { base: "{colors.white.500A}", _dark: "{colors.white.500A}" } } }, blackAlpha: { bold: { value: { base: "{colors.black.700A}", _dark: "{colors.black.700A}" } }, default: { value: { base: "{colors.black.500A}", _dark: "{colors.black.500A}" } }, selected: { value: { base: "{colors.black.600A}", _dark: "{colors.black.600A}" } }, disabled: { value: { base: "{colors.black.500A}", _dark: "{colors.black.500A}" } } } }, heybeePrimary: { default: { value: { base: "{colors.yellow.500}", _dark: "{colors.yellow.500}" } }, selected: { value: { base: "{colors.yellow.600}", _dark: "{colors.yellow.600}" } } } }, surface: { base: { value: { base: "{colors.neutral.1100}", _dark: "{colors.neutral.0}" } }, layer_1: { value: { base: "{colors.neutral.1100}", _dark: "{colors.neutral.100}" } }, layer_2: { value: { base: "{colors.neutral.1050}", _dark: "{colors.neutral.200}" } } }, shadow: { overlay: { value: { base: "{colors.black.100A}", _dark: "{colors.black.400A}" } }, raised: { value: { base: "{colors.black.400A}", _dark: "{colors.black.600A}" } } }, scrim: { default: { value: { base: "{colors.black.600A}", _dark: "{colors.black.600A}" } } }, skeleton: { default: { value: { base: "{colors.neutral.800}", _dark: "{colors.neutral.100}" } }, subtle: { value: { base: "{colors.neutral.700}", _dark: "{colors.neutral.200}" } } }, border: { neutral: { default: { value: { base: "{colors.neutral.700}", _dark: "{colors.neutral.400}" } }, subtle: { value: { base: "{colors.neutral.900}", _dark: "{colors.neutral.300}" } }, disabled: { value: { base: "{colors.neutral.1000}", _dark: "{colors.neutral.200}" } } }, neuroidPrimary: { default: { value: { base: "{colors.purple.500}", _dark: "{colors.purple.400}" } } }, danger: { default: { value: { base: "{colors.red.500}", _dark: "{colors.red.400}" } } }, warning: { default: { value: { base: "{colors.orange.500}", _dark: "{colors.orange.400}" } } }, success: { default: { value: { base: "{colors.green.500}", _dark: "{colors.green.400}" } } }, informative: { default: { value: { base: "{colors.blue.500}", _dark: "{colors.blue.400}" } } }, zoltarinaPrimary: { default: { value: { base: "{colors.ohre.800}", _dark: "{colors.ohre.400}" } } }, heydPrimary: { default: { value: { base: "{colors.cyan.800}", _dark: "{colors.cyan.400}" } } }, heybeePrimary: { default: { value: { base: "{colors.yellow.800}", _dark: "{colors.yellow.500}" } } } } }, shadows: { raised: { value: "0px 1px 3px 0px {colors.shadow.raised}" }, overlay: { value: "0px 20px 25px -5px {colors.shadow.overlay}" } } }, v = { colors: { neutral: { 0: { value: "#080A0E" }, 100: { value: "#101216" }, 200: { value: "#181A1E" }, 300: { value: "#282A2E" }, 400: { value: "#383A3E" }, 500: { value: "#505256" }, 600: { value: "#64666A" }, 700: { value: "#787A7E" }, 800: { value: "#A0A2A6" }, 900: { value: "#B4B6BA" }, 1e3: { value: "#F2F4F8" }, 1050: { value: "#EDEEF1" }, 1100: { value: "#FAFCFF" }, 1200: { value: "#F8F9FF" } }, black: { "700A": { value: "rgba(0,0,0,0.8)" }, "600A": { value: "rgba(0,0,0,0.6)" }, "500A": { value: "rgba(0,0,0,0.4)" }, "400A": { value: "rgba(0,0,0,0.32)" }, "300A": { value: "rgba(0,0,0,0.2)" }, "200A": { value: "rgba(0,0,0,0.12)" }, "100A": { value: "rgba(0,0,0,0.08)" } }, white: { "700A": { value: "rgba(255,255,255,0.8)" }, "600A": { value: "rgba(255,255,255,0.6)" }, "500A": { value: "rgba(255,255,255,0.4)" }, "400A": { value: "rgba(255,255,255,0.32)" }, "300A": { value: "rgba(255,255,255,0.2)" }, "200A": { value: "rgba(255,255,255,0.12)" }, "100A": { value: "rgba(255,255,255,0.08)" } }, red: { 100: { value: "#ffeceb" }, 200: { value: "#ffd5d2" }, 300: { value: "#fd9891" }, 400: { value: "#f87168" }, 500: { value: "#f15b50" }, 600: { value: "#e2483d" }, 700: { value: "#c9372c" }, 800: { value: "#87241c" }, 900: { value: "#5d1f1a" }, 1e3: { value: "#42221f" } }, orange: { 100: { value: "#fff5eb" }, 200: { value: "#ffe9d2" }, 300: { value: "#fdc991" }, 400: { value: "#f8b268" }, 500: { value: "#f1a350" }, 600: { value: "#e2923d" }, 700: { value: "#c97d2c" }, 800: { value: "#87531c" }, 900: { value: "#5d3d1a" }, 1e3: { value: "#42311f" } }, blue: { 100: { value: "#ebf2ff" }, 200: { value: "#d2e1ff" }, 300: { value: "#91b5fd" }, 400: { value: "#6898f8" }, 500: { value: "#5086f1" }, 600: { value: "#3d74e2" }, 700: { value: "#2c60c9" }, 800: { value: "#1c4087" }, 900: { value: "#1a305d" }, 1e3: { value: "#1f2b42" } }, green: { 100: { value: "#ebfff5" }, 200: { value: "#9cfccc" }, 300: { value: "#47EB99" }, 400: { value: "#26d980" }, 500: { value: "#14b866" }, 600: { value: "#10934c" }, 700: { value: "#147042" }, 800: { value: "#125433" }, 900: { value: "#104129" }, 1e3: { value: "#0b2819" } }, purple: { 100: { value: "#f3ebff" }, 200: { value: "#e9ddfd" }, 300: { value: "#cbacfb" }, 400: { value: "#ac7cf8" }, 500: { value: "#8d4bf6" }, 600: { value: "#6d19f5" }, 700: { value: "#570ad1" }, 800: { value: "#4308a0" }, 900: { value: "#2f0670" }, 1e3: { value: "#1a033f" } }, ohre: { 100: { value: "#FFF8F1" }, 200: { value: "#FFE6C8" }, 300: { value: "#FFD3A0" }, 400: { value: "#FFC077" }, 500: { value: "#E2A763" }, 600: { value: "#C58F50" }, 700: { value: "#A8773F" }, 800: { value: "#8A6030" }, 900: { value: "#6D4B22" }, 1e3: { value: "#503617" } }, cyan: { 100: { value: "#ecffff" }, 200: { value: "#c1feff" }, 300: { value: "#96feff" }, 400: { value: "#6bfdff" }, 500: { value: "#3df1f3" }, 600: { value: "#2acfd1" }, 700: { value: "#1aadaf" }, 800: { value: "#0e8c8d" }, 900: { value: "#056a6b" }, 1e3: { value: "#004849" } }, yellow: { 100: { value: "#FFFBED" }, 200: { value: "#FFF3C5" }, 300: { value: "#FFEB9D" }, 400: { value: "#FFE375" }, 500: { value: "#FFDB4D" }, 600: { value: "#DDBC38" }, 700: { value: "#BB9D27" }, 800: { value: "#997F19" }, 900: { value: "#77620E" }, 1e3: { value: "#554506" } } }, borderWidths: { none: { value: "0px" }, sm: { value: "1px" }, md: { value: "2px" }, lg: { value: "4px" } }, spacing: { 0: { value: "0rem" }, 1: { value: "0.25rem" }, 2: { value: "0.5rem" }, 3: { value: "0.75rem" }, 4: { value: "1rem" }, 6: { value: "1.5rem" }, 8: { value: "2rem" }, 12: { value: "3rem" }, 20: { value: "5rem" }, 30: { value: "7.5rem" }, 56: { value: "14rem" }, 72: { value: "18rem" }, 98: { value: "24rem" }, 128: { value: "32rem" }, 160: { value: "40rem" } }, radii: { none: { value: "0px" }, xs: { value: "2px" }, sm: { value: "4px" }, md: { value: "8px" }, lg: { value: "16px" }, full: { value: "9999px" } }, fontSizes: { xs: { value: "0.75rem" }, sm: { value: "0.875rem" }, md: { value: "1rem" }, lg: { value: "1.25rem" }, xl: { value: "1.5rem" }, "2xl": { value: "2rem" }, "3xl": { value: "2.5rem" }, "4xl": { value: "3rem" } }, letterSpacings: { xs: { value: "-1.5px" }, sm: { value: "-1.2px" }, md: { value: "-1px" }, lg: { value: "-0.8px" }, xl: { value: "-0.6px" }, "2xl": { value: "-0.4px" }, "3xl": { value: "-0.2px" } }, lineHeights: { md: { value: "1rem" }, lg: { value: "1.25rem" }, xl: { value: "1.5rem" }, "2xl": { value: "1.75rem" }, "3xl": { value: "2.25rem" }, "4xl": { value: "2.75rem" }, "5xl": { value: "3rem" } }, fontWeights: { regular: { value: "400" }, medium: { value: "500" }, semibold: { value: "600" }, bold: { value: "700" }, regularItalic: { value: "Italic" }, mediumItalic: { value: "Medium Italic" } }, fonts: { inter: { value: "Inter" }, notoSans: { value: "Noto Sans" } } }, $ = { body: { md: { value: { fontFamily: "notoSans", fontWeight: "regular", fontSize: "sm", lineHeight: "lg", letterSpacing: "3xl" } }, lg: { value: { fontFamily: "notoSans", fontWeight: "regular", fontSize: "md", lineHeight: "xl", letterSpacing: "3xl" } }, sm: { value: { fontSize: "xs", fontWeight: "regular", fontFamily: "notoSans", lineHeight: "md", letterSpacing: "3xl" } } }, label: { sm: { value: { fontFamily: "notoSans", fontWeight: "medium", fontSize: "xs", lineHeight: "md", letterSpacing: "3xl" } }, md: { value: { fontFamily: "notoSans", fontWeight: "medium", fontSize: "sm", lineHeight: "lg", letterSpacing: "3xl" } } }, title: { sm: { value: { fontFamily: "notoSans", fontWeight: "medium", fontSize: "sm", lineHeight: "lg", letterSpacing: "2xl" } }, md: { value: { fontFamily: "notoSans", fontWeight: "medium", fontSize: "md", lineHeight: "xl", letterSpacing: "xl" } }, lg: { value: { fontFamily: "notoSans", fontWeight: "semibold", fontSize: "lg", lineHeight: "2xl", letterSpacing: "xl" } } }, headline: { sm: { value: { fontFamily: "inter", fontWeight: "semibold", fontSize: "xl", lineHeight: "2xl", letterSpacing: "lg" } }, md: { value: { fontFamily: "inter", fontWeight: "bold", fontSize: "2xl", lineHeight: "3xl", letterSpacing: "md" } } }, display: { md: { value: { fontFamily: "inter", fontWeight: "bold", fontSize: "3xl", lineHeight: "4xl", letterSpacing: "sm" } }, lg: { value: { fontFamily: "inter", fontWeight: "bold", fontSize: "4xl", lineHeight: "5xl", letterSpacing: "xs" } } } }, g = { semantic: m, primitive: v, textStyles: $ };
+const conditions = {
+  extend: {
+    collapsed: '&:is([aria-collapsed=true], [data-collapsed], [data-state="collapsed"])',
+    current: "&:is([data-current])",
+    hidden: "&:is([hidden])",
+    hover: ["@media (hover: hover) and (pointer: fine)", "&:is(:hover, [data-hover])"],
+    indeterminate: "&:is(:indeterminate, [data-indeterminate], [aria-checked=mixed], [data-state=indeterminate])",
+    off: '&:is([data-state="off"])',
+    on: '&:is([data-state="on"])',
+    today: "&:is([data-today])",
+    underValue: '&:is([data-state="under-value"])',
+    dark: ".dark &",
+    light: ":root &, .light &",
+    invalid: "&:is([aria-invalid])"
+  }
+};
+const breakpoints = {
+  sm: "640px",
+  md: "768px",
+  lg: "1024px",
+  xl: "1280px",
+  "2xl": "1536px"
+};
+const animations = defineTokens.animations({
+  "backdrop-in": {
+    value: "fade-in 250ms {easings.emphasized-in}"
+  },
+  "backdrop-out": {
+    value: "fade-out 200ms {easings.emphasized-out}"
+  },
+  "dialog-in": {
+    value: "slide-in 400ms {easings.emphasized-in}"
+  },
+  "dialog-out": {
+    value: "slide-out 200ms {easings.emphasized-out}"
+  },
+  "drawer-in-left": {
+    value: "slide-in-left 400ms {easings.emphasized-in}"
+  },
+  "drawer-out-left": {
+    value: "slide-out-left 200ms {easings.emphasized-out}"
+  },
+  "drawer-in-right": {
+    value: "slide-in-right 400ms {easings.emphasized-in}"
+  },
+  "drawer-out-right": {
+    value: "slide-out-right 200ms {easings.emphasized-out}"
+  },
+  "skeleton-pulse": {
+    value: "skeleton-pulse 2s {easings.pulse} infinite"
+  },
+  "fade-in": {
+    value: "fade-in 400ms {easings.emphasized-in}"
+  },
+  "collapse-in": {
+    value: "collapse-in 250ms {easings.emphasized-in}"
+  },
+  "collapse-out": {
+    value: "collapse-out 200ms {easings.emphasized-out}"
+  },
+  spin: {
+    value: "spin 1s linear infinite"
+  }
+});
+const blurs = defineTokens.blurs({
+  sm: { value: "4px" },
+  base: { value: "8px" },
+  md: { value: "12px" },
+  lg: { value: "16px" },
+  xl: { value: "24px" },
+  "2xl": { value: "40px" },
+  "3xl": { value: "64px" }
+});
+const borders = {
+  none: { value: "none" }
+};
+const durations = defineTokens.durations({
+  fastest: { value: "50ms" },
+  faster: { value: "100ms" },
+  fast: { value: "150ms" },
+  normal: { value: "200ms" },
+  slow: { value: "300ms" },
+  slower: { value: "400ms" },
+  slowest: { value: "500ms" }
+});
+const easings = defineTokens.easings({
+  pulse: { value: "cubic-bezier(0.4, 0.0, 0.6, 1.0)" },
+  default: { value: "cubic-bezier(0.2, 0.0, 0, 1.0)" },
+  "emphasized-in": { value: "cubic-bezier(0.05, 0.7, 0.1, 1.0)" },
+  "emphasized-out": { value: "cubic-bezier(0.3, 0.0, 0.8, 0.15)" }
+});
+const spacing = defineTokens.spacing({
+  0: { value: "0rem" },
+  0.5: { value: "0.125rem" },
+  1: { value: "0.25rem" },
+  1.5: { value: "0.375rem" },
+  2: { value: "0.5rem" },
+  2.5: { value: "0.625rem" },
+  3: { value: "0.75rem" },
+  3.5: { value: "0.875rem" },
+  4: { value: "1rem" },
+  4.5: { value: "1.125rem" },
+  5: { value: "1.25rem" },
+  6: { value: "1.5rem" },
+  7: { value: "1.75rem" },
+  8: { value: "2rem" },
+  9: { value: "2.25rem" },
+  10: { value: "2.5rem" },
+  11: { value: "2.75rem" },
+  12: { value: "3rem" },
+  14: { value: "3.5rem" },
+  16: { value: "4rem" },
+  20: { value: "5rem" },
+  24: { value: "6rem" },
+  28: { value: "7rem" },
+  32: { value: "8rem" },
+  36: { value: "9rem" },
+  40: { value: "10rem" },
+  44: { value: "11rem" },
+  48: { value: "12rem" },
+  52: { value: "13rem" },
+  56: { value: "14rem" },
+  60: { value: "15rem" },
+  64: { value: "16rem" },
+  72: { value: "18rem" },
+  80: { value: "20rem" },
+  96: { value: "24rem" }
+});
+const largeSizes = {
+  "2xs": { value: "16rem" },
+  xs: { value: "20rem" },
+  sm: { value: "24rem" },
+  md: { value: "28rem" },
+  lg: { value: "32rem" },
+  xl: { value: "36rem" },
+  "2xl": { value: "42rem" },
+  "3xl": { value: "48rem" },
+  "4xl": { value: "56rem" },
+  "5xl": { value: "64rem" },
+  "6xl": { value: "72rem" },
+  "7xl": { value: "80rem" },
+  "8xl": { value: "90rem" }
+};
+const sizes = {
+  ...spacing,
+  ...largeSizes,
+  full: { value: "100%" },
+  min: { value: "min-content" },
+  max: { value: "max-content" },
+  fit: { value: "fit-content" }
+};
+const zIndex = defineTokens.zIndex({
+  hide: {
+    value: -1
+  },
+  base: {
+    value: 0
+  },
+  docked: {
+    value: 10
+  },
+  dropdown: {
+    value: 1e3
+  },
+  sticky: {
+    value: 1100
+  },
+  banner: {
+    value: 1200
+  },
+  overlay: {
+    value: 1300
+  },
+  modal: {
+    value: 1400
+  },
+  popover: {
+    value: 1500
+  },
+  skipLink: {
+    value: 1600
+  },
+  toast: {
+    value: 1700
+  },
+  tooltip: {
+    value: 1800
+  }
+});
+const tokens = defineTokens({
+  animations,
+  blurs,
+  borders,
+  //   colors,
+  durations,
+  easings,
+  //   fonts,
+  //   fontSizes,
+  //   fontWeights,
+  //   letterSpacings,
+  //   lineHeights,
+  //   radii,
+  sizes,
+  // spacing,
+  zIndex,
+  ...g.primitive
+});
+const preset = definePreset({
+  name: "@nation-a/theme",
+  conditions,
+  globalCss: {
+    ...globalCss
+  },
+  theme: {
+    extend: {
+      breakpoints,
+      keyframes,
+      tokens,
+      semanticTokens: g.semantic,
+      textStyles: g.textStyles
+    }
+  }
+});
+exports.Button = Button;
+exports.Dialog = Dialog;
+exports.IconButton = IconButton;
+exports.Portal = Portal;
+exports.Spinner = Spinner;
+exports.Text = Text;
+exports.preset = preset;
+//# sourceMappingURL=index.cjs.map