chaeditor 0.1.0

package/dist/panda-primitives.cjs

@@ -0,0 +1,1299 @@
+'use strict';
+
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var reactDom = require('react-dom');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+// src/shared/ui/button/button.tsx
+
+// styled-system/helpers.mjs
+function isObject(value) {
+  return typeof value === "object" && value != null && !Array.isArray(value);
+}
+var isObjectOrArray = (obj) => typeof obj === "object" && obj !== null;
+function compact(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([_, value2]) => value2 !== void 0));
+}
+var isBaseCondition = (v) => v === "base";
+function filterBaseConditions(c) {
+  return c.slice().filter((v) => !isBaseCondition(v));
+}
+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;
+};
+var MERGE_OMIT = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function mergeProps(...sources) {
+  return sources.reduce((prev, obj) => {
+    if (!obj) return prev;
+    Object.keys(obj).forEach((key) => {
+      if (MERGE_OMIT.has(key)) return;
+      const prevValue = prev[key];
+      const value = obj[key];
+      if (isObject(prevValue) && isObject(value)) {
+        prev[key] = mergeProps(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?.(prop, child) ?? prop;
+        const childPath = [...path, key];
+        if (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 toResponsiveObject(values, breakpoints) {
+  return values.reduce(
+    (acc, current, index) => {
+      const key = breakpoints[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: (v) => v,
+  finalize: (v) => v,
+  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(style) && Object.keys(compact(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(...resolve(styles));
+  }
+  function assignCss2(...styles) {
+    return Object.assign({}, ...resolve(styles));
+  }
+  return { mergeCss: memo(mergeCss2), assignCss: assignCss2 };
+}
+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 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,%";
+`(?:${lengthUnits.split(",").join("|")})`;
+var getSlotRecipes = (recipe = {}) => {
+  const init = (slot) => ({
+    className: [recipe.className, slot].filter(Boolean).join("__"),
+    base: recipe.base?.[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]) => {
+        slotRecipe.variants[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 set = items.reduce((acc, currItems) => {
+    if (currItems) {
+      currItems.forEach((item) => acc.add(item));
+    }
+    return acc;
+  }, /* @__PURE__ */ new Set([]));
+  return Array.from(set);
+};
+
+// styled-system/css/conditions.mjs
+var 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,_noscript,_invertedColors,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,@/xs,@/sm,@/md,@/lg,@/xl,@/2xl,@/3xl,@/4xl,@/5xl,@/6xl,@/7xl,@/8xl,base";
+var conditions = new Set(conditionsStr.split(","));
+var conditionRegex = /^@|&|&$/;
+function isCondition(value) {
+  return conditions.has(value) || conditionRegex.test(value);
+}
+var underscoreRegex = /^_/;
+var conditionsSelectorRegex = /&|@/;
+function finalizeConditions(paths) {
+  return paths.map((path) => {
+    if (conditions.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;
+  });
+}
+
+// styled-system/css/css.mjs
+var 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,focusRing:focus-ring,focusVisibleRing:focus-v-ring,focusRingColor:focus-ring-c,focusRingOffset:focus-ring-o,focusRingWidth:focus-ring-w,focusRingStyle:focus-ring-s,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,boxSize:size,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,WebkitTextFillColor:wktf-c,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,backgroundLinear:bg-linear/bgLinear,backgroundRadial:bg-radial/bgRadial,backgroundConic:bg-conic/bgConic,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,borderBlockStartWidth:bd-bs-w,borderBlockEndWidth:bd-be-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,cursor:cursor,textStyle:textStyle";
+var classNameByProp = /* @__PURE__ */ new Map();
+var 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);
+    });
+  }
+});
+var resolveShorthand = (prop) => shorthands.get(prop) || prop;
+var 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
+  }
+};
+var cssFn = createCss(context);
+var css = (...styles) => cssFn(mergeCss(...styles));
+css.raw = (...styles) => mergeCss(...styles);
+var { mergeCss} = createMergeCss(context);
+
+// styled-system/css/cx.mjs
+function cx() {
+  let str = "", i = 0, arg;
+  for (; i < arguments.length; ) {
+    if ((arg = arguments[i++]) && typeof arg === "string") {
+      str && (str += " ");
+      str += arg;
+    }
+  }
+  return str;
+}
+
+// styled-system/css/cva.mjs
+var defaults = (conf) => ({
+  base: {},
+  variants: {},
+  defaultVariants: {},
+  compoundVariants: [],
+  ...conf
+});
+function cva(config) {
+  const { base, variants, defaultVariants, compoundVariants } = defaults(config);
+  const getVariantProps = (variants2) => ({ ...defaultVariants, ...compact(variants2) });
+  function resolve(props = {}) {
+    const computedVariants = getVariantProps(props);
+    let variantCss = { ...base };
+    for (const [key, value] of Object.entries(computedVariants)) {
+      if (variants[key]?.[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(defaultVariants, override.defaultVariants),
+      compoundVariants: [...compoundVariants, ...override.compoundVariants]
+    });
+  }
+  function cvaFn(props) {
+    return css(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;
+}
+
+// styled-system/css/sva.mjs
+function sva(config) {
+  const slots = Object.entries(getSlotRecipes(config)).map(([slot, slotCva]) => [slot, cva(slotCva)]);
+  const defaultVariants = config.defaultVariants ?? {};
+  const classNameMap = slots.reduce((acc, [slot, cvaFn]) => {
+    if (config.className) acc[slot] = cvaFn.config.className;
+    return acc;
+  }, {});
+  function svaFn(props) {
+    const result = slots.map(([slot, cvaFn]) => [slot, cx(cvaFn(props), classNameMap[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(variants2) });
+  const variantMap = Object.fromEntries(
+    Object.entries(variants).map(([key, value]) => [key, Object.keys(value)])
+  );
+  return Object.assign(memo(svaFn), {
+    __cva__: false,
+    raw,
+    config,
+    variantMap,
+    variantKeys,
+    classNameMap,
+    splitVariantProps,
+    getVariantProps
+  });
+}
+
+// src/entities/editor-core/model/theme-contract.ts
+var CHAEDITOR_THEME_VARIABLES = {
+  overlayBackdrop: "--chaeditor-color-overlay-backdrop",
+  primaryHover: "--chaeditor-color-primary-hover"};
+var CHAEDITOR_THEME_DEFAULTS = {
+  light: {
+    overlayBackdrop: "rgb(15 23 42 / 0.86)"}
+};
+
+// src/shared/ui/styles/primitive-theme.ts
+var focusVisibleRingStyles = {
+  outlineColor: "focusRing",
+  outlineOffset: "[2px]",
+  outlineStyle: "solid",
+  outlineWidth: "[2px]"
+};
+var disabledFieldStyles = {
+  cursor: "not-allowed",
+  opacity: 0.56
+};
+var disabledButtonStyles = {
+  cursor: "not-allowed",
+  opacity: 0.48,
+  pointerEvents: "none"
+};
+var primaryHoverBackground = `[var(${CHAEDITOR_THEME_VARIABLES.primaryHover},var(--colors-primary))]`;
+var overlayBackdropColor = `[var(${CHAEDITOR_THEME_VARIABLES.overlayBackdrop},${CHAEDITOR_THEME_DEFAULTS.light.overlayBackdrop})]`;
+var overlayBackdropStyleValue = `var(${CHAEDITOR_THEME_VARIABLES.overlayBackdrop},${CHAEDITOR_THEME_DEFAULTS.light.overlayBackdrop})`;
+var buttonRecipe = sva({
+  slots: ["root", "label", "visual"],
+  base: {
+    root: {
+      appearance: "none",
+      display: "inline-flex",
+      alignItems: "center",
+      justifyContent: "center",
+      gap: "2",
+      userSelect: "none",
+      cursor: "pointer",
+      transition: "colors",
+      letterSpacing: "[-0.01em]",
+      _focusVisible: {
+        ...focusVisibleRingStyles
+      },
+      _disabled: disabledButtonStyles,
+      '&[aria-disabled="true"]': {
+        ...disabledButtonStyles
+      }
+    },
+    label: {
+      display: "inline-flex",
+      alignItems: "center",
+      minWidth: "0"
+    },
+    visual: {
+      display: "inline-flex",
+      alignItems: "center",
+      justifyContent: "center",
+      flex: "none"
+    }
+  },
+  variants: {
+    fullWidth: {
+      true: { root: { width: "full" } },
+      false: { root: { width: "auto" } }
+    },
+    size: {
+      xs: { root: { fontSize: "xs" } },
+      sm: { root: { fontSize: "sm" } },
+      md: { root: { fontSize: "sm" } }
+    },
+    variant: {
+      solid: {
+        root: {
+          borderStyle: "solid",
+          borderWidth: "1px",
+          borderRadius: "full"
+        }
+      },
+      ghost: {
+        root: {
+          borderStyle: "solid",
+          borderWidth: "1px",
+          borderRadius: "full",
+          background: "transparent"
+        }
+      },
+      underline: {
+        root: {
+          minHeight: "auto",
+          p: "0",
+          textDecoration: "underline",
+          textUnderlineOffset: "[0.18em]"
+        }
+      }
+    },
+    tone: {
+      white: {},
+      primary: {},
+      black: {}
+    }
+  },
+  compoundVariants: [
+    /* Layout rules for the solid and ghost variants. */
+    {
+      variant: ["solid", "ghost"],
+      size: "xs",
+      css: { root: { minHeight: "8", px: "2" } }
+    },
+    {
+      variant: ["solid", "ghost"],
+      size: "sm",
+      css: { root: { minHeight: "[2.375rem]", px: "3" } }
+    },
+    {
+      variant: ["solid", "ghost"],
+      size: "md",
+      css: { root: { minHeight: "[2.75rem]", px: "4" } }
+    },
+    /* Colors for the solid variant. */
+    {
+      tone: "white",
+      variant: "solid",
+      css: {
+        root: {
+          background: "surface",
+          borderColor: "border",
+          color: "text",
+          _hover: { borderColor: "borderStrong" }
+        }
+      }
+    },
+    {
+      tone: "primary",
+      variant: "solid",
+      css: {
+        root: {
+          background: "primary",
+          color: "primaryContrast",
+          borderColor: "transparent",
+          _hover: { background: primaryHoverBackground }
+        }
+      }
+    },
+    {
+      tone: "black",
+      variant: "solid",
+      css: {
+        root: {
+          background: "text",
+          color: "surface",
+          borderColor: "transparent"
+        }
+      }
+    },
+    /* Colors for the ghost and underline variants. */
+    {
+      tone: "white",
+      variant: ["ghost", "underline"],
+      css: { root: { color: "text", borderColor: "transparent" } }
+    },
+    {
+      tone: "primary",
+      variant: ["ghost", "underline"],
+      css: { root: { color: "primary", borderColor: "transparent" } }
+    },
+    {
+      tone: "black",
+      variant: ["ghost", "underline"],
+      css: { root: { color: "text", borderColor: "transparent" } }
+    }
+  ],
+  defaultVariants: {
+    fullWidth: false,
+    size: "md",
+    tone: "white",
+    variant: "solid"
+  }
+});
+var Button = React.forwardRef(
+  ({
+    asChild = false,
+    children,
+    className,
+    fullWidth,
+    labelClassName,
+    leadingVisual,
+    leadingVisualClassName,
+    size,
+    tone,
+    trailingVisual,
+    trailingVisualClassName,
+    type = "button",
+    variant,
+    ...props
+  }, ref) => {
+    const styles = buttonRecipe({ fullWidth, size, tone, variant });
+    const isDisabled = props.disabled || props["aria-disabled"] === "true";
+    const renderContent = (labelContent) => /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      leadingVisual && /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, className: cx(styles.visual, leadingVisualClassName), children: leadingVisual }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: cx(styles.label, labelClassName), children: labelContent }),
+      trailingVisual && /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, className: cx(styles.visual, trailingVisualClassName), children: trailingVisual })
+    ] });
+    if (asChild) {
+      if (!React__default.default.isValidElement(children)) {
+        throw new Error("Button with asChild requires a single React element child.");
+      }
+      const child = children;
+      const isNativeButtonElement = typeof child.type === "string" && child.type === "button";
+      const nextProps = {
+        ...props,
+        className: cx(styles.root, className, child.props.className),
+        children: renderContent(child.props.children)
+      };
+      if (isNativeButtonElement) {
+        nextProps.type = type;
+      }
+      if (isDisabled && !isNativeButtonElement) {
+        delete nextProps.disabled;
+        nextProps["aria-disabled"] = "true";
+        nextProps.tabIndex = -1;
+        nextProps.onClick = (event) => {
+          event.preventDefault();
+          event.stopPropagation();
+        };
+      }
+      return React__default.default.cloneElement(child, nextProps);
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        ...props,
+        ref,
+        className: cx(styles.root, className),
+        type,
+        disabled: props.disabled,
+        children: renderContent(children)
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+var Input = React__default.default.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("input", { ...props, className: cx(inputRecipe(), className), ref })
+);
+Input.displayName = "Input";
+var inputRecipe = cva({
+  base: {
+    width: "full",
+    minHeight: "[2.75rem]",
+    px: "3",
+    py: "2",
+    borderRadius: "md",
+    borderWidth: "1px",
+    borderStyle: "solid",
+    borderColor: "border",
+    backgroundColor: "transparent",
+    color: "text",
+    transition: "colors",
+    _placeholder: {
+      color: "muted"
+    },
+    _hover: {
+      borderColor: "borderStrong"
+    },
+    _focusVisible: {
+      ...focusVisibleRingStyles,
+      borderColor: "primary"
+    },
+    _disabled: disabledFieldStyles
+  }
+});
+
+// src/shared/lib/a11y/get-focusable-elements.ts
+var FOCUSABLE_SELECTOR = 'button:not([disabled]), [href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
+var getFocusableElements = (container) => Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR)).filter(
+  (element) => !element.hasAttribute("hidden") && element.getAttribute("aria-hidden") !== "true"
+);
+
+// src/shared/lib/react/use-dialog-focus-management.ts
+var useDialogFocusManagement = ({
+  containerRef,
+  initialFocusRef,
+  isEnabled,
+  onEscape,
+  restoreFocusRef
+}) => {
+  const previousActiveElementRef = React.useRef(null);
+  const onEscapeRef = React.useRef(onEscape);
+  React.useEffect(() => {
+    onEscapeRef.current = onEscape;
+  }, [onEscape]);
+  React.useEffect(() => {
+    if (!isEnabled) return;
+    previousActiveElementRef.current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+    const requestFocus = () => {
+      const container = containerRef.current;
+      if (!container) return;
+      const fallbackTarget = initialFocusRef?.current ?? getFocusableElements(container)[0] ?? container;
+      fallbackTarget.focus();
+    };
+    const rafId = window.requestAnimationFrame(requestFocus);
+    const handleKeydown = (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        event.stopPropagation();
+        onEscapeRef.current();
+        return;
+      }
+      if (event.key !== "Tab") return;
+      const container = containerRef.current;
+      if (!container) return;
+      const focusableElements = getFocusableElements(container);
+      if (focusableElements.length === 0) {
+        event.preventDefault();
+        container.focus();
+        return;
+      }
+      const activeElement = document.activeElement;
+      const activeIndex = activeElement ? focusableElements.indexOf(activeElement) : -1;
+      if (event.shiftKey && (activeIndex <= 0 || activeIndex === -1)) {
+        event.preventDefault();
+        focusableElements[focusableElements.length - 1]?.focus();
+        return;
+      }
+      if (!event.shiftKey && (activeIndex === -1 || activeIndex === focusableElements.length - 1)) {
+        event.preventDefault();
+        focusableElements[0]?.focus();
+      }
+    };
+    window.addEventListener("keydown", handleKeydown);
+    return () => {
+      window.cancelAnimationFrame(rafId);
+      window.removeEventListener("keydown", handleKeydown);
+      if (restoreFocusRef?.current !== false) {
+        previousActiveElementRef.current?.focus();
+      }
+      if (restoreFocusRef) {
+        restoreFocusRef.current = true;
+      }
+    };
+  }, [containerRef, initialFocusRef, isEnabled, restoreFocusRef]);
+};
+var XButton = React__default.default.forwardRef(
+  ({
+    ariaLabel,
+    className,
+    glyphClassName,
+    size = "sm",
+    tone = "black",
+    type = "button",
+    variant = "ghost",
+    ...props
+  }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+    Button,
+    {
+      "aria-label": ariaLabel,
+      className,
+      ref,
+      size,
+      tone,
+      type,
+      variant,
+      ...props,
+      children: /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": true, className: cx(glyphClass, glyphClassName), children: "+" })
+    }
+  )
+);
+XButton.displayName = "XButton";
+var glyphClass = css({
+  display: "inline-block",
+  fontSize: "3xl",
+  lineHeight: "none",
+  transform: "rotate(45deg)"
+});
+var Modal = ({
+  ariaDescribedBy,
+  ariaLabel,
+  ariaLabelledBy,
+  backdropClassName,
+  children,
+  closeAriaLabel,
+  closeButtonClassName,
+  frameClassName,
+  initialFocusRef,
+  isOpen,
+  onClose
+}) => {
+  const [isMounted, setIsMounted] = React.useState(false);
+  const frameRef = React.useRef(null);
+  React.useEffect(() => {
+    setIsMounted(true);
+  }, []);
+  React.useEffect(() => {
+    if (!isOpen || !isMounted) return;
+    const bodyOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = bodyOverflow;
+    };
+  }, [isMounted, isOpen]);
+  useDialogFocusManagement({
+    containerRef: frameRef,
+    initialFocusRef,
+    isEnabled: isOpen && isMounted,
+    onEscape: onClose
+  });
+  if (!isMounted || !isOpen) return null;
+  return reactDom.createPortal(
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        onClick: (event) => {
+          if (event.target === event.currentTarget) onClose();
+        },
+        className: cx(backdropClass, backdropClassName),
+        style: { background: overlayBackdropStyleValue },
+        children: /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            "aria-describedby": ariaDescribedBy,
+            "aria-label": ariaLabel,
+            "aria-labelledby": ariaLabelledBy,
+            "aria-modal": "true",
+            ref: frameRef,
+            role: "dialog",
+            tabIndex: -1,
+            className: cx(frameBaseClass, frameClassName),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                XButton,
+                {
+                  ariaLabel: closeAriaLabel,
+                  className: cx(closeButtonClass, closeButtonClassName),
+                  onClick: onClose
+                }
+              ),
+              children
+            ]
+          }
+        )
+      }
+    ),
+    document.body
+  );
+};
+var backdropClass = css({
+  position: "fixed",
+  inset: "0",
+  zIndex: "1200",
+  backgroundColor: overlayBackdropColor,
+  p: "4",
+  display: "grid",
+  placeItems: "center",
+  overflow: "hidden"
+});
+var frameBaseClass = css({
+  position: "relative",
+  borderRadius: "3xl",
+  maxWidth: "full",
+  display: "flex",
+  flexDirection: "column",
+  maxHeight: "full",
+  minWidth: "0",
+  minHeight: "0",
+  overflow: "hidden"
+});
+var closeButtonClass = css({
+  position: "absolute",
+  top: "[0.6rem]",
+  right: "[0.5rem]",
+  zIndex: "10",
+  lineHeight: "none"
+});
+
+// src/shared/ui/styles/sr-only-style.ts
+var srOnlyClass = css({
+  srOnly: true
+});
+var Tooltip = ({
+  children,
+  className,
+  content,
+  contentClassName,
+  forceOpen = false,
+  openOnFocus = true,
+  portalClassName,
+  preferredPlacement = "top"
+}) => {
+  const [isFocused, setIsFocused] = React.useState(false);
+  const [isHovering, setIsHovering] = React.useState(false);
+  const [tooltipStyle, setTooltipStyle] = React.useState();
+  const rootRef = React.useRef(null);
+  const tooltipId = React.useId();
+  const isOpen = forceOpen || isHovering || openOnFocus && isFocused;
+  if (!React.isValidElement(children)) {
+    throw new Error("Tooltip requires a single React element child.");
+  }
+  const triggerElement = children;
+  const childProps = triggerElement.props;
+  const describedBy = [childProps["aria-describedby"], isOpen ? tooltipId : null].filter(Boolean).join(" ");
+  React.useLayoutEffect(() => {
+    if (!isOpen) {
+      setTooltipStyle(void 0);
+      return;
+    }
+    const updateTooltipPosition = () => {
+      if (!rootRef.current) return;
+      const triggerRect = rootRef.current.getBoundingClientRect();
+      const availableSpaceAbove = triggerRect.top;
+      const availableSpaceBelow = window.innerHeight - triggerRect.bottom;
+      const shouldPlaceBelow = preferredPlacement === "bottom" ? true : preferredPlacement === "top" ? false : availableSpaceAbove < 40 && availableSpaceBelow >= availableSpaceAbove;
+      setTooltipStyle({
+        left: triggerRect.left + triggerRect.width / 2,
+        position: "fixed",
+        top: shouldPlaceBelow ? triggerRect.bottom + 8 : triggerRect.top - 8,
+        transform: shouldPlaceBelow ? "translate(-50%, 0)" : "translate(-50%, -100%)"
+      });
+    };
+    updateTooltipPosition();
+    window.addEventListener("resize", updateTooltipPosition);
+    window.addEventListener("scroll", updateTooltipPosition, true);
+    return () => {
+      window.removeEventListener("resize", updateTooltipPosition);
+      window.removeEventListener("scroll", updateTooltipPosition, true);
+    };
+  }, [isOpen, preferredPlacement]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "span",
+    {
+      className: cx(rootClass, className),
+      ref: rootRef,
+      onBlurCapture: () => {
+        if (!openOnFocus) return;
+        setIsFocused(false);
+      },
+      onFocusCapture: () => {
+        if (!openOnFocus) return;
+        setIsFocused(true);
+      },
+      onMouseEnter: () => setIsHovering(true),
+      onMouseLeave: () => setIsHovering(false),
+      children: [
+        React.cloneElement(triggerElement, {
+          "aria-describedby": describedBy || void 0
+        }),
+        isOpen ? reactDom.createPortal(
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "span",
+            {
+              className: cx(tooltipPortalClass, portalClassName),
+              id: tooltipId,
+              role: "tooltip",
+              style: {
+                ...tooltipStyle,
+                visibility: tooltipStyle ? "visible" : "hidden"
+              },
+              children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: cx(tooltipClass, contentClassName), children: content })
+            }
+          ),
+          document.body
+        ) : null
+      ]
+    }
+  );
+};
+var rootClass = css({
+  display: "inline-flex",
+  flex: "none"
+});
+var tooltipClass = css({
+  px: "2",
+  py: "1",
+  borderRadius: "md",
+  backgroundColor: "[rgba(15,23,42,0.92)]",
+  color: "white",
+  borderWidth: "1px",
+  borderStyle: "solid",
+  borderColor: "[rgba(255,255,255,0.08)]",
+  fontSize: "xs",
+  lineHeight: "tight",
+  whiteSpace: "nowrap",
+  boxShadow: "[0_12px_28px_rgba(15,23,42,0.28)]"
+});
+var tooltipPortalClass = css({
+  zIndex: "[9999]",
+  pointerEvents: "none"
+});
+var Popover = ({
+  children,
+  isOpen: controlledIsOpen,
+  label,
+  onOpenChange,
+  onTriggerMouseDown,
+  panelClassName,
+  panelLabel,
+  portalPlacement = "end",
+  renderInPortal = false,
+  rootClassName,
+  triggerAriaLabel,
+  triggerClassName,
+  triggerContent,
+  triggerLabelClassName,
+  triggerSize = "sm",
+  triggerTone = "white",
+  triggerTooltip,
+  triggerValueClassName,
+  triggerVariant = "ghost",
+  value
+}) => {
+  const [uncontrolledIsOpen, setUncontrolledIsOpen] = React.useState(false);
+  const isControlled = typeof controlledIsOpen === "boolean";
+  const isOpen = isControlled ? controlledIsOpen : uncontrolledIsOpen;
+  const rootRef = React.useRef(null);
+  const triggerRef = React.useRef(null);
+  const panelRef = React.useRef(null);
+  const restoreFocusRef = React.useRef(true);
+  const [portalStyle, setPortalStyle] = React.useState();
+  const panelId = React.useId();
+  const panelLabelId = React.useId();
+  const triggerLabelId = React.useId();
+  const valueId = React.useId();
+  const resolvedTriggerLabel = triggerAriaLabel ?? panelLabel;
+  const usesSharedLabel = resolvedTriggerLabel === panelLabel;
+  const setOpen = React.useCallback(
+    (nextOpen) => {
+      if (!isControlled) {
+        setUncontrolledIsOpen(nextOpen);
+      }
+      onOpenChange?.(nextOpen);
+    },
+    [isControlled, onOpenChange]
+  );
+  React.useEffect(() => {
+    if (!isOpen) return;
+    const handleOutsideInteraction = (event) => {
+      const eventTarget = event.target;
+      if (!rootRef.current?.contains(eventTarget) && !panelRef.current?.contains(eventTarget)) {
+        setOpen(false);
+      }
+    };
+    window.addEventListener("click", handleOutsideInteraction);
+    window.addEventListener("pointerdown", handleOutsideInteraction);
+    return () => {
+      window.removeEventListener("click", handleOutsideInteraction);
+      window.removeEventListener("pointerdown", handleOutsideInteraction);
+    };
+  }, [isOpen, setOpen]);
+  React.useLayoutEffect(() => {
+    if (!isOpen || !renderInPortal) return;
+    const updatePortalPosition = () => {
+      if (!triggerRef.current) return;
+      const triggerRect = triggerRef.current.getBoundingClientRect();
+      const baseTop = triggerRect.bottom + 9;
+      if (portalPlacement === "start") {
+        setPortalStyle({
+          left: triggerRect.left,
+          position: "fixed",
+          top: baseTop
+        });
+        return;
+      }
+      setPortalStyle({
+        position: "fixed",
+        right: Math.max(window.innerWidth - triggerRect.right, 0),
+        top: baseTop
+      });
+    };
+    updatePortalPosition();
+    window.addEventListener("resize", updatePortalPosition);
+    window.addEventListener("scroll", updatePortalPosition, true);
+    return () => {
+      window.removeEventListener("resize", updatePortalPosition);
+      window.removeEventListener("scroll", updatePortalPosition, true);
+    };
+  }, [isOpen, portalPlacement, renderInPortal]);
+  useDialogFocusManagement({
+    containerRef: panelRef,
+    initialFocusRef: void 0,
+    isEnabled: isOpen,
+    onEscape: () => {
+      setOpen(false);
+    },
+    restoreFocusRef
+  });
+  const closePopover = (options) => {
+    restoreFocusRef.current = options?.restoreFocus ?? true;
+    setOpen(false);
+  };
+  const triggerButton = /* @__PURE__ */ jsxRuntime.jsx(
+    Button,
+    {
+      "aria-controls": isOpen ? panelId : void 0,
+      "aria-describedby": !triggerContent && value ? valueId : void 0,
+      "aria-expanded": isOpen,
+      "aria-haspopup": "dialog",
+      "aria-labelledby": usesSharedLabel ? panelLabelId : triggerLabelId,
+      className: cx(triggerButtonClass, triggerClassName),
+      onClick: () => setOpen(!isOpen),
+      onMouseDown: onTriggerMouseDown,
+      ref: triggerRef,
+      size: triggerSize,
+      tone: triggerTone,
+      type: "button",
+      variant: triggerVariant,
+      children: triggerContent ? triggerContent : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: cx(triggerLabelClass, triggerLabelClassName), children: label }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: cx(triggerValueClass, triggerValueClassName), id: valueId, children: value })
+      ] })
+    }
+  );
+  const panel = isOpen ? /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "aria-labelledby": panelLabelId,
+      className: cx(panelClass, renderInPortal ? portaledPanelClass : void 0, panelClassName),
+      id: panelId,
+      ref: panelRef,
+      role: "dialog",
+      style: renderInPortal ? portalStyle : void 0,
+      tabIndex: -1,
+      children: typeof children === "function" ? children({ closePopover }) : children
+    }
+  ) : null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cx(rootClass2, rootClassName), ref: rootRef, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: srOnlyClass, id: panelLabelId, children: panelLabel }),
+    !usesSharedLabel ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: srOnlyClass, id: triggerLabelId, children: resolvedTriggerLabel }) : null,
+    triggerTooltip ? /* @__PURE__ */ jsxRuntime.jsx(Tooltip, { content: triggerTooltip, children: triggerButton }) : triggerButton,
+    renderInPortal && panel ? reactDom.createPortal(panel, document.body) : panel
+  ] });
+};
+var rootClass2 = css({
+  position: "relative"
+});
+var triggerButtonClass = css({
+  _hover: {
+    color: "primary"
+  },
+  _focusVisible: {
+    ...focusVisibleRingStyles,
+    color: "primary"
+  }
+});
+var triggerLabelClass = css({
+  fontSize: "xs",
+  fontWeight: "bold",
+  letterSpacing: "[0.12em]",
+  textTransform: "uppercase",
+  color: "muted"
+});
+var triggerValueClass = css({
+  fontSize: "sm",
+  color: "text"
+});
+var panelClass = css({
+  position: "absolute",
+  top: "[calc(100% + 0.55rem)]",
+  right: "0",
+  minWidth: "48",
+  p: "2",
+  borderRadius: "2xl",
+  border: "[1px solid var(--colors-border)]",
+  backgroundColor: "surface",
+  boxShadow: "floating",
+  display: "grid",
+  gap: "1",
+  zIndex: "30"
+});
+var portaledPanelClass = css({
+  top: "[auto]",
+  right: "[auto]"
+});
+var resizeTextarea = (element) => {
+  element.style.height = "0px";
+  element.style.height = `${element.scrollHeight}px`;
+};
+var Textarea = React__default.default.forwardRef(
+  ({ autoResize = true, className, onChange, rows = 1, style, ...props }, ref) => {
+    const innerRef = React.useRef(null);
+    React.useLayoutEffect(() => {
+      if (!autoResize || !innerRef.current) return;
+      resizeTextarea(innerRef.current);
+    }, [autoResize, props.value]);
+    const handleRef = (node) => {
+      innerRef.current = node;
+      if (!ref) return;
+      if (typeof ref === "function") {
+        ref(node);
+        return;
+      }
+      ref.current = node;
+    };
+    const handleChange = (event) => {
+      if (autoResize) {
+        resizeTextarea(event.currentTarget);
+      }
+      onChange?.(event);
+    };
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "textarea",
+      {
+        ...props,
+        className: cx(textareaRecipe({ autoResize }), className),
+        onChange: handleChange,
+        ref: handleRef,
+        rows,
+        style
+      }
+    );
+  }
+);
+Textarea.displayName = "Textarea";
+var textareaRecipe = cva({
+  base: {
+    width: "full",
+    px: "3",
+    py: "2",
+    borderRadius: "md",
+    borderWidth: "1px",
+    borderStyle: "solid",
+    borderColor: "border",
+    backgroundColor: "transparent",
+    color: "text",
+    resize: "vertical",
+    transition: "colors",
+    _placeholder: {
+      color: "muted"
+    },
+    _hover: {
+      borderColor: "borderStrong"
+    },
+    _focusVisible: {
+      ...focusVisibleRingStyles,
+      borderColor: "primary"
+    },
+    _disabled: disabledFieldStyles,
+    '&[aria-disabled="true"]': {
+      ...disabledFieldStyles
+    }
+  },
+  variants: {
+    autoResize: {
+      true: {
+        resize: "none",
+        overflow: "hidden"
+      },
+      false: {}
+    }
+  },
+  defaultVariants: {
+    autoResize: true
+  }
+});
+
+// src/shared/ui/primitive-registry/default-markdown-primitive-registry.ts
+var defaultMarkdownPrimitiveRegistry = {
+  Button,
+  Input,
+  Modal,
+  Popover,
+  Textarea,
+  Tooltip
+};
+var createDefaultMarkdownPrimitiveRegistry = () => defaultMarkdownPrimitiveRegistry;
+var createPandaMarkdownPrimitiveRegistry = () => defaultMarkdownPrimitiveRegistry;
+
+exports.Button = Button;
+exports.Input = Input;
+exports.Modal = Modal;
+exports.Popover = Popover;
+exports.Textarea = Textarea;
+exports.Tooltip = Tooltip;
+exports.buttonRecipe = buttonRecipe;
+exports.createDefaultMarkdownPrimitiveRegistry = createDefaultMarkdownPrimitiveRegistry;
+exports.createPandaMarkdownPrimitiveRegistry = createPandaMarkdownPrimitiveRegistry;